ITS/AliITSv11GeometrySSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //*************************************************************************
  19 // SSD geometry, based on ROOT geometrical modeler
  20 //
  21 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  22 //*************************************************************************
  23 #include "TMath.h"
  24 #include "TGeoVolume.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "TVector3.h"
  28 #include "TGeoArb8.h"
  29 #include "TList.h"
  30 #include "TGeoMatrix.h"
  31 #include "TGeoCompositeShape.h"
  32 #include "TGeoTube.h"
  33 #include "TGeoBBox.h"
  34 #include "TGeoXtru.h"
  35 #include "TGeoTorus.h"
  36 #include "TGeoPgon.h"
  37 #include "TRotation.h"
  38 #include "AliITSv11GeometrySSD.h"
  39 /////////////////////////////////////////////////////////////////////////////////
  40 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  41 /////////////////////////////////////////////////////////////////////////////////
  42 const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
  43 const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
  44 /////////////////////////////////////////////////////////////////////////////////
  45 //Parameters for SSD Geometry
  46 /////////////////////////////////////////////////////////////////////////////////
  47 // Layer5 (lengths are in mm and angles in degrees)
  48 /////////////////////////////////////////////////////////////////////////////////
  49 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  50 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  51 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  52 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  53 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  54 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  55 /////////////////////////////////////////////////////////////////////////////////
  56 // Layer6 (lengths are in mm and angles in degrees)
  57 /////////////////////////////////////////////////////////////////////////////////
  58 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  59 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  60 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  61 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  62 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  63 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  64 /////////////////////////////////////////////////////////////////////////////////
  65 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  66 /////////////////////////////////////////////////////////////////////////////////
  67 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  68 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  69 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  70 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  71 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  74 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  75 /////////////////////////////////////////////////////////////////////////////////
  76 // Stiffener (lengths are in mm and angles in degrees)
  77 /////////////////////////////////////////////////////////////////////////////////
  78 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  79 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  80 //const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
  81 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315*fgkmm;
  82 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  84 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  86 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  87 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
  88 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   0.700*fgkmm; // multiplied by 0.5
  89 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  =
  92                                                                                                            {44.32*fgkmm, 0.33*fgkmm};
  93 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
  94 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
  96 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =
  97                                                                                                           0.25*fgkSSDStiffenerHeight;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 100 /////////////////////////////////////////////////////////////////////////////////
 101 // Cooling Block (lengths are in mm and angles in degrees)
 102 /////////////////////////////////////////////////////////////////////////////////
 103 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 104 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 105 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 106                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 107 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 108                                                                                                           {1.000*fgkmm, 0.120*fgkmm};
 109 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 110                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 111 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 112                                                                                                                                          1.500*fgkmm;
 113 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 114                                                                                                                                          0.300*fgkmm;
 115 /////////////////////////////////////////////////////////////////////////////////
 116 // SSD Sensor (lengths are in mm and angles in degrees)
 117 /////////////////////////////////////////////////////////////////////////////////
 118 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 119                                                                                                                  "SSDSensorSensitiveVol";
 120 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 121 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 122 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 123 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 124                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 125 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 126 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 127 /////////////////////////////////////////////////////////////////////////////////
 128 // Flex (lengths are in mm and angles in degrees)
 129 /////////////////////////////////////////////////////////////////////////////////
 130 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 131 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 132                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 133                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 134                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 135                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 136                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 137 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 138                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 139 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 140                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 142 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 143 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 144 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 145                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 146 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 147                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 148 /////////////////////////////////////////////////////////////////////////////////
 149 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 150 /////////////////////////////////////////////////////////////////////////////////
 151 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 152 /////////////////////////////////////////////////////////////////////////////////
 153 // SSD Module (lengths are in mm and angles in degrees)
 154 /////////////////////////////////////////////////////////////////////////////////
 155 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 156                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 157 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 158                                                                                                                                         45.600*fgkmm;
 159 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 160                                                                                                                                          5.075*fgkmm;
 161 /////////////////////////////////////////////////////////////////////////////////
 162 // Sensor Support (lengths are in mm and angles in degrees)
 163 /////////////////////////////////////////////////////////////////////////////////
 164 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 165                                                                                                                                          5.800*fgkmm;
 166 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 167                                                                                                                                          2.000*fgkmm;
 168 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 169                                                                                                      { 4.620*fgkmm, 5.180*fgkmm};
 170 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 171                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 172 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 173                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 174                                                             +  fgkSSDSensorSideSupportThickness[0])
 175                                                                 -  fgkSSDSensorSideSupportLength;
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 177                                                                                                                                     5.250*fgkmm;
 178 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 179                                                                                                                                         1.680*fgkmm;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 181                                                                   = {fgkSSDSensorSideSupportHeight[0]
 182                                                                   +  fgkSSDSensorSideSupportThickness[0],
 183                                                                          fgkSSDSensorSideSupportHeight[1]
 184                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 185 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 186                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 187                                                                           fgkSSDSensorSideSupportThickness[1]};
 188 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 189                                                                                                                                    19.000*fgkmm;
 190 /////////////////////////////////////////////////////////////////////////////////
 191 // Chip Cables (lengths are in mm and angles in degrees)
 192 /////////////////////////////////////////////////////////////////////////////////
 193 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 194                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 195 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 196                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 197                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 198                                                                   -   fgkSSDSensorSideSupportHeight[0])
 199                                                                   -   fgkSSDCoolingBlockHoleCenter
 200                                                                   -   fgkSSDStiffenerHeight
 201                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 202                                                                           fgkSSDModuleCoolingBlockToSensor
 203                                                                   -   fgkSSDCoolingBlockHoleCenter
 204                                                                   -       fgkSSDStiffenerHeight
 205                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 206 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 207                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 208 /////////////////////////////////////////////////////////////////////////////////
 209 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 210 /////////////////////////////////////////////////////////////////////////////////
 211 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 212                                                                                                                                         3.820*fgkmm;
 213 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 214 //                                                                                                                                         3.780;
 215 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 216                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 217 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 218                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 219 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 220                                                                                                                                 { 30.00, 90.00};
 221 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 222                                                                                                                                          1.78*fgkmm;
 223 /////////////////////////////////////////////////////////////////////////////////
 224 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 225 /////////////////////////////////////////////////////////////////////////////////
 226 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 227                                                                    = fgkSSDModuleSensorSupportDistance
 228                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 229 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 230 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 231                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 232 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 233                                                                                                                                         1.630*fgkmm;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 235 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 236                                                                         = fgkCarbonFiberTriangleLength
 237                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 238                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 239                                                                         * TMath::DegToRad());
 240 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 241                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 242                                                                         - fgkCarbonFiberSupportWidth)
 243                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 244                                                                         - fgkCarbonFiberSupportWidth;
 245 /////////////////////////////////////////////////////////////////////////////////
 246 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 247 /////////////////////////////////////////////////////////////////////////////////
 248 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 249                                                                                                                                           =  0.950*fgkmm;
 250 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 251                                                                                                                                           =  1.600*fgkmm;
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 253                                                                                                                                           =  0.830*fgkmm;
 254 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 255                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 256 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 257                                                                         = fgkCarbonFiberJunctionWidth
 258                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 259                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 260 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 261                                                                         = {fgkCarbonFiberLowerSupportWidth
 262                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 263                                                                            fgkCarbonFiberLowerSupportWidth
 264                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 265                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 266 /////////////////////////////////////////////////////////////////////////////////
 267 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 268 /////////////////////////////////////////////////////////////////////////////////
 269 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 270                                                            {0.5 * (fgkSSDLay5LadderLength
 271                                                                         -  fgkSSDLay5SensorsNumber
 272                                                                         *  fgkCarbonFiberJunctionWidth
 273                                                                         -  fgkCarbonFiberLowerSupportWidth),
 274                                                                 0.5 * (fgkSSDLay5LadderLength
 275                                                                         -  fgkSSDLay5SensorsNumber
 276                                                                         *  fgkCarbonFiberJunctionWidth
 277                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 278 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 279                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 280                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 281 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 282                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 283                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 284 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 285                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 286 /////////////////////////////////////////////////////////////////////////////////
 287 // Cooling Tube Support (lengths are in mm and angles in degrees)
 288 /////////////////////////////////////////////////////////////////////////////////
 289 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 290 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 291                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 292 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 293 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 294 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 295 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 296                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 297 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 298                                                                                                                                           11.70*fgkmm;
 299 /////////////////////////////////////////////////////////////////////////////////
 300 // Cooling Tube (lengths are in mm and angles in degrees)
 301 /////////////////////////////////////////////////////////////////////////////////
 302 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 303 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  0.96*fgkmm;
 304 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 305                                                                                                         fgkCarbonFiberJunctionWidth;
 306 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 307                                                                          fgkSSDModuleSensorSupportDistance
 308                                                                   +      fgkSSDCoolingBlockLength;
 309 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 310 /////////////////////////////////////////////////////////////////////////////////
 311 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 312 /////////////////////////////////////////////////////////////////////////////////
 313 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 314                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 315 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 316                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 317 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 318                                                                                                                                           20.0*fgkmm;
 319 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 320                                                                                                                                                     40.0;
 321 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 322                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 323 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 324                                                                                                                                           2.5*fgkmm;
 325 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 326                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 327 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 328                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 329 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 330                                                                                                                                           1.0*fgkmm;
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 332                                                                                                                                           6.0*fgkmm;
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =
 334                                                                                                                                           4.0*fgkmm;
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 336                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 337 /////////////////////////////////////////////////////////////////////////////////
 338 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 339 /////////////////////////////////////////////////////////////////////////////////
 340 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 341 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 342 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 343 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 344 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 345 /////////////////////////////////////////////////////////////////////////////////
 346 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 347 /////////////////////////////////////////////////////////////////////////////////
 348 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 349 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 350 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 351                                                                                                   -  fgkSSDMountingBlockHeight[1]
 352                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 353                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 354                                                                                                   -      fgkMountingBlockSupportDownHeight,
 355                                                                                                          fgkSSDLay6RadiusMin
 356                                                                                                   -  fgkSSDMountingBlockHeight[1]
 357                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 358                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 359                                                                                                   -      fgkMountingBlockSupportDownHeight};
 360 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 361                                                                                                     -  fgkSSDMountingBlockHeight[1]
 362                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 363                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 364                                                                                                         -  fgkMountingBlockSupportRadius[0],
 365                                                                                                            fgkSSDLay6RadiusMax
 366                                                                                                     -  fgkSSDMountingBlockHeight[1]
 367                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 368                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 369                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 370 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
 371 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 372 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 373 /////////////////////////////////////////////////////////////////////////////////
 374 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 375 /////////////////////////////////////////////////////////////////////////////////
 376 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 377 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 378 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 379 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 380                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 381 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 382                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 383 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 384                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 385 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 386 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 387 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 388 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 389 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 390 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 391 /////////////////////////////////////////////////////////////////////////////////
 392 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 393 /////////////////////////////////////////////////////////////////////////////////
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 397 /////////////////////////////////////////////////////////////////////////////////
 398 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 399 /////////////////////////////////////////////////////////////////////////////////
 400 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 401                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 402 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 405                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 406 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 407                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 409 /////////////////////////////////////////////////////////////////////////////////
 410 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 411 /////////////////////////////////////////////////////////////////////////////////
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 413                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 415                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 416                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 417 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 418 /////////////////////////////////////////////////////////////////////////////////
 419 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 420 /////////////////////////////////////////////////////////////////////////////////
 421 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 422                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 423 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 424                                                                                                             {47.1*fgkmm,0.35*fgkmm};
 425 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 426                                                                                                                                           1.0*fgkmm;
 427 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 428 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 429                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 430 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 431                                                                                                                                          0.15*fgkmm;
 432 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 433                                                                                                                                          19.0*fgkmm;
 434 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 435                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 436 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 437                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 438 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 439                                                                                                                                           2.1*fgkmm;
 440 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 441                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 442 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 443                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 444 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 445                                                                                                                                            19*fgkmm;
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 447                                                                                                                                           1.0*fgkmm;
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 449                                                                                                                                           3.6*fgkmm;
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 451                                                                                                                                          61.0*fgkmm;
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 453                                                                                                                                          5.97*fgkmm;
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 455 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 456                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 457                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 459                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 461                                                                                                                                           1.0*fgkmm;
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 463                                                                                                                                    = 0.15*fgkmm;
 464 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 465                                                                                                                                          20.0*fgkmm;
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 467 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 469 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 471 /////////////////////////////////////////////////////////////////////////////////
 472 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 473 /////////////////////////////////////////////////////////////////////////////////
 474 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 475 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
 477 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 479 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
 480 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 481 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 483 /////////////////////////////////////////////////////////////////////////////////
 484 ClassImp(AliITSv11GeometrySSD)
 485 /////////////////////////////////////////////////////////////////////////////////
 486 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 487   AliITSv11Geometry(),
 488   fSSDChipMedium(),
 489   fSSDChipGlueMedium(),
 490   fSSDStiffenerMedium(),
 491   fSSDStiffenerConnectorMedium(),
 492   fSSDStiffener0603CapacitorMedium(),
 493   fSSDStiffener1812CapacitorMedium(),
 494   fSSDStiffenerHybridWireMedium(),
 495   fSSDKaptonFlexMedium(),
 496   fSSDAlTraceFlexMedium(),
 497   fSSDAlTraceLadderCableMedium(),
 498   fSSDKaptonLadderCableMedium(),
 499   fSSDKaptonChipCableMedium(),
 500   fSSDAlTraceChipCableMedium(),
 501   fSSDAlCoolBlockMedium(),
 502   fSSDSensorMedium(),
 503   fSSDSensorSupportMedium(),
 504   fSSDCarbonFiberMedium(),
 505   fSSDTubeHolderMedium(),
 506   fSSDCoolingTubeWater(),
 507   fSSDCoolingTubePhynox(),
 508   fSSDSupportRingAl(),
 509   fSSDMountingBlockMedium(),
 510   fSSDAir(),
 511   fCreateMaterials(kFALSE),
 512   fTransformationMatrices(kFALSE),
 513   fBasicObjects(kFALSE),
 514   fcarbonfiberjunction(),
 515   fcoolingtubesupport(),
 516   fhybridmatrix(),
 517   fssdcoolingblocksystem(),
 518   fcoolingblocksystematrix(),
 519   fssdstiffenerflex(),
 520   fssdendflex(),
 521   fendladdercoolingtubesupportmatrix(),
 522   fendladdermountingblock(),
 523   fendladdermountingblockclip(),
 524   fSSDSensor5(),
 525   fSSDSensor6(),
 526   fSSDLayer5(),
 527   fSSDLayer6(),
 528   fMotherVol(),
 529   fLay5LadderSupportRing(),
 530   fLay6LadderSupportRing(),
 531   fgkEndCapSupportSystem(),
 532   fColorCarbonFiber(4),
 533   fColorRyton(5),
 534   fColorPhynox(14),
 535   fColorSilicon(3),
 536   fColorAl(38),
 537   fColorKapton(6),
 538   fColorPolyhamide(5),
 539   fColorStiffener(9),
 540   fColorEpoxy(30),
 541   fColorWater(7),
 542   fColorG10(41)
 543 {
 544   ////////////////////////
 545   // Standard constructor
 546   ////////////////////////
 547 }
 548 /////////////////////////////////////////////////////////////////////////////////
 549 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
 550   AliITSv11Geometry(s.GetDebug()),
 551   fSSDChipMedium(s.fSSDChipMedium),
 552   fSSDChipGlueMedium(s.fSSDChipGlueMedium),
 553   fSSDStiffenerMedium(s.fSSDStiffenerMedium),
 554   fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
 555   fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
 556   fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
 557   fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
 558   fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
 559   fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
 560   fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
 561   fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
 562   fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
 563   fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
 564   fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
 565   fSSDSensorMedium(s.fSSDSensorMedium),
 566   fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
 567   fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
 568   fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
 569   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
 570   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
 571   fSSDSupportRingAl(s.fSSDSupportRingAl),
 572   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
 573   fSSDAir(s.fSSDAir),
 574   fCreateMaterials(s.fCreateMaterials),
 575   fTransformationMatrices(s.fTransformationMatrices),
 576   fBasicObjects(s.fBasicObjects),
 577   fcarbonfiberjunction(s.fcarbonfiberjunction),
 578   fcoolingtubesupport(s.fcoolingtubesupport),
 579   fhybridmatrix(s.fhybridmatrix),
 580   fssdcoolingblocksystem(s.fssdcoolingblocksystem),
 581   fcoolingblocksystematrix(s.fcoolingblocksystematrix),
 582   fssdstiffenerflex(s.fssdstiffenerflex),
 583   fssdendflex(s.fssdendflex),
 584   fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
 585   fendladdermountingblock(s.fendladdermountingblock),
 586   fendladdermountingblockclip(s.fendladdermountingblockclip),
 587   fSSDSensor5(s.fSSDSensor5),
 588   fSSDSensor6(s.fSSDSensor6),
 589   fSSDLayer5(s.fSSDLayer5),
 590   fSSDLayer6(s.fSSDLayer6),
 591   fMotherVol(s.fMotherVol),
 592   fLay5LadderSupportRing(s.fLay5LadderSupportRing),
 593   fLay6LadderSupportRing(s.fLay6LadderSupportRing),
 594   fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
 595   fColorCarbonFiber(s.fColorCarbonFiber),
 596   fColorRyton(s.fColorRyton),
 597   fColorPhynox(s.fColorPhynox),
 598   fColorSilicon(s.fColorSilicon),
 599   fColorAl(s.fColorAl),
 600   fColorKapton(s.fColorKapton),
 601   fColorPolyhamide(s.fColorPolyhamide),
 602   fColorStiffener(s.fColorStiffener),
 603   fColorEpoxy(s.fColorEpoxy),
 604   fColorWater(s.fColorWater),
 605   fColorG10(s.fColorG10)
 606 {
 607   ////////////////////////
 608   // Copy Constructor
 609   ////////////////////////
 610 }
 611 /////////////////////////////////////////////////////////////////////////////////
 612 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
 613 operator=(const AliITSv11GeometrySSD &s){
 614   ////////////////////////
 615   // Assignment operator
 616   ////////////////////////
 617   this->~AliITSv11GeometrySSD();
 618   new(this) AliITSv11GeometrySSD(s);
 619   return *this;
 620 /*
 621   if(&s == this) return *this;
 622   fMotherVol = s.fMotherVol;
 623   return *this;
 624  */
 625 }
 626 ///////////////////////////////////////////////////////////////////////////////
 627 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 628   ///////////////////////////////////////////////////////////////////////
 629   // Method generating the trasformation matrix for the whole SSD Geometry
 630   ///////////////////////////////////////////////////////////////////////
 631   // Setting some variables for Carbon Fiber Supportmatrix creation
 632   //////////////////////////////////////////////////////////////////////
 633   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 634                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 635   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 636                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 637                                                                  +      fgkCarbonFiberSupportWidth);
 638   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 639                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 640   TGeoRotation* carbonfiberot[3];
 641   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 642   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 643   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 644   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 645   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 646                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 647                                                   -  fgkCarbonFiberTriangleLength
 648                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 649   ///////////////////////////////////////////
 650   //Setting Local Translations and Rotations:
 651   ///////////////////////////////////////////
 652   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 653   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 654                                                                          0.5*carbonfibersupportheight,NULL);
 655   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 656                                                                          2.*symmetryplaneposition+transvector[1],
 657                                                                          transvector[2], carbonfiberot[2]);
 658   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 659   /////////////////////////////////////////////////////////////
 660   // Carbon Fiber Support Transformations
 661   /////////////////////////////////////////////////////////////
 662   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 663   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 664                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 665                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 666                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 667   }
 668   /////////////////////////////////////////////////////////////
 669   // Carbon Fiber Junction Transformation
 670   /////////////////////////////////////////////////////////////
 671   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 672   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 673   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 674   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 675   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 676         localcarbonfiberjunctionmatrix[i] =
 677                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 678         localcarbonfiberjunctionrot[i] =
 679                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 680         localcarbonfiberjunctiontrans[i] =
 681                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 682   }
 683   ///////////////////////
 684   // Setting Translations
 685   ///////////////////////
 686   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 687   localcarbonfiberjunctiontrans[1][0] =
 688                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 689   localcarbonfiberjunctiontrans[2][0] =
 690                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 691                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 692                                  fgkCarbonFiberTriangleLength
 693                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 694   localcarbonfiberjunctiontrans[0][1] =
 695                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 696   localcarbonfiberjunctiontrans[1][1] =
 697                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 698   localcarbonfiberjunctiontrans[2][1] =
 699                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 700   ////////////////////
 701   // Setting Rotations
 702   ////////////////////
 703   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 704                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 705                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 706   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 707         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 708   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 709   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 710   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 711   ////////////////////////////////////////
 712   // Setting Carbon Fiber Junction matrix
 713   ////////////////////////////////////////
 714   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 715                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 716                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 717                         localcarbonfiberjunctionmatrix[i][j] =
 718                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 719                                                            *localcarbonfiberjunctionrot[i][j]);
 720                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 721          }
 722   }
 723   /////////////////////////////////////////////////////////////
 724   // Carbon Fiber Lower Support Transformations
 725   /////////////////////////////////////////////////////////////
 726   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 727   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 728                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 729                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 730                                                                          0.0);
 731   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 732                                                                          fgkCarbonFiberJunctionWidth
 733                                                                 -    fgkCarbonFiberLowerSupportWidth
 734                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 735                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 736                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 737    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 738    fcarbonfiberlowersupportrans[0] =
 739                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 740    fcarbonfiberlowersupportrans[1] =
 741                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 742   /////////////////////////////////////////////////////////////
 743   // SSD Sensor Support Transformations
 744   /////////////////////////////////////////////////////////////
 745   const Int_t kssdsensorsupportmatrixnumber = 3;
 746   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 747   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 748   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 749   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 750         localssdsensorsupportmatrix[i] =
 751                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 752         localssdsensorsupportrot[i] =
 753                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 754         localssdsensorsupportrans[i] =
 755                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 756   }
 757   ///////////////////////
 758   // Setting Translations
 759   ///////////////////////
 760   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 761                                                                           0.5*fgkSSDSensorSideSupportWidth,
 762                                                                           0.0);
 763   localssdsensorsupportrans[1][0] =
 764                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 765   localssdsensorsupportrans[2][0] =
 766                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 767   localssdsensorsupportrans[0][1] =
 768                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 769                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 770                                                                                 0.0);
 771   localssdsensorsupportrans[1][1] =
 772                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 773                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 774                                                                     -   fgkSSDModuleSensorSupportDistance,
 775                                                                                 0.0);
 776   localssdsensorsupportrans[2][1] =
 777                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 778                                                                         -    fgkSSDSensorCenterSupportPosition,
 779                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 780                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 781                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 782   localssdsensorsupportrans[0][2] =
 783                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 784                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 785                                                                                  fgkCarbonFiberJunctionWidth
 786                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 787                                                                         +    fgkSSDSensorCenterSupportLength
 788                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 789                                                                         -    fgkSSDSensorCenterSupportPosition,
 790                                                                              0.0);
 791   localssdsensorsupportrans[1][2] =
 792                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 793   localssdsensorsupportrans[2][2] =
 794                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 795   ////////////////////
 796   // Setting Rotations
 797   ////////////////////
 798   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 799                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 800                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 801   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 802         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 803         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 804   }
 805   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 806   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 807   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 808   ////////////////////////////////////////
 809   // SSD Sensor Support matrix
 810   ////////////////////////////////////////
 811   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 812                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 813                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 814                         localssdsensorsupportmatrix[i][j] =
 815                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 816                                                            *localssdsensorsupportrot[i][j]);
 817                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 818          }
 819   }
 820   /////////////////////////////////////////////////////////////
 821   // SSD Cooling Tube Support Transformations
 822   /////////////////////////////////////////////////////////////
 823   const Int_t kcoolingtubesupportmatrixnumber = 2;
 824   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 825   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 826   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 827   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 828                                                                                                         /fgkCoolingTubeSupportRmax);
 829   localcoolingtubesupportrans[0] =
 830                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 831                                                 +  2.*(fgkCoolingTubeSupportLength
 832                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 833                                                 +  fgkCarbonFiberTriangleLength
 834                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 835   localcoolingtubesupportrans[1] =
 836                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 837                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 838                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 839                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 840                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 841                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 842                                         +          fgkSSDSensorCenterSupportLength
 843                     -      fgkSSDSensorCenterSupportThickness[0])
 844                                         +  0.5*fgkSSDSensorLength,
 845                                         -  0.5*fgkCoolingTubeSupportHeight);
 846   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 847   localcoolingtubesupportrot[i] = new TGeoRotation();
 848   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 849   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 850   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 851         localcoolingtubesupportmatrix[i] =
 852                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 853                                                    *localcoolingtubesupportrot[i]);
 854   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 855   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 856                                                                 (*localcoolingtubesupportmatrix[0]));
 857   /////////////////////////////////////////////////////////////
 858   // End Ladder SSD Cooling Tube Support Transformations
 859   /////////////////////////////////////////////////////////////
 860   TGeoTranslation** localendladdercooltubetrans[2];
 861   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 862   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 863   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 864   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 865                                                                                         -          (fgkCoolingTubeSupportLength
 866                                                                                         -               fgkCoolingTubeSupportRmax),
 867                                                                                                         fgkEndLadderMountingBlockPosition[0]
 868                                                                                         -               fgkendladdercoolingsupportdistance[0]
 869                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 870                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 871   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 872                                                                                         -          (fgkCoolingTubeSupportLength
 873                                                                                         -               fgkCoolingTubeSupportRmax),
 874                                                                                                         fgkEndLadderMountingBlockPosition[0]
 875                                                                                         +               fgkendladdercoolingsupportdistance[1]
 876                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 877                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 878   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 879                                                                                         -       fgkCoolingTubeSupportRmax)
 880                                                                                         +               fgkCarbonFiberTriangleLength
 881                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 882                                                                                                 0.0,
 883                                                                                                 0.0);
 884   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 885                                                                                                         fgkendladdercoolingsupportdistance[0]
 886                                                                                         +               fgkendladdercoolingsupportdistance[1],
 887                                                                                                         0.0);
 888   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 889   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 890                                                                                         +               fgkCarbonFiberJunctionLength
 891                                                                                         -               fgkCoolingTubeSupportLength,
 892                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 893                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 894                                                                                                    -fgkendladdercoolingsupportdistance[2],
 895                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 896   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 897                                                                                         +               fgkCoolingTubeSupportLength
 898                                                                                         -               fgkCoolingTubeSupportRmax
 899                                                                                         -               fgkCarbonFiberJunctionLength,
 900                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 901                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 902                                                                                         -               fgkendladdercoolingsupportdistance[2],
 903                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 904   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 905   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 906   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 907   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 908   (*localcoolingtubesupportrot[1]));
 909   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 910   (*localcoolingtubesupportrot[1]));
 911   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 912   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 913   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 914   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 915   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 916
 917   fendladdercoolingtubesupportmatrix[1][0] =
 918                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 919                                                                                    *(*localcoolingtubesupportrot[1]));
 920   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 921   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 922   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 923   /////////////////////////////////////////////////////////////
 924   // SSD Cooling Tube Transformations
 925   /////////////////////////////////////////////////////////////
 926   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 927   localcoolingtuberot->SetAngles(0.,90.,0.);
 928   TGeoTranslation** localcoolingtubetrans[4];
 929   TVector3** localcoolingtubevect[4];
 930   for(Int_t i=0; i<4; i++){
 931         localcoolingtubevect[i] = new TVector3*[2];
 932         localcoolingtubetrans[i] = new TGeoTranslation*[2];
 933         fcoolingtubematrix[i] = new TGeoHMatrix*[2];
 934   }
 935   localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 936                                                   -fgkCarbonFiberTriangleLength),
 937                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 938                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 939                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 940                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 941                                                   +      fgkSSDSensorCenterSupportLength
 942                                                   -      fgkSSDSensorCenterSupportThickness[0])+
 943                                                          0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
 944                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 945                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 946                                                   -  0.5*fgkCoolingTubeSupportWidth,
 947                                                   -  0.5*fgkCoolingTubeSupportHeight);
 948   localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
 949                                                         localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
 950                                                   -  2.0*fgkSSDModuleStiffenerPosition[1]
 951                                                   -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
 952                                                   +  fgkCoolingTubeSupportWidth,
 953                                                   localcoolingtubevect[0][0]->Z());
 954   localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
 955                                                          +                               fgkCarbonFiberTriangleLength,
 956                                                                                          localcoolingtubevect[0][0]->Y(),
 957                                                                                          localcoolingtubevect[0][0]->Z());
 958   localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
 959                                                          +                               fgkCarbonFiberTriangleLength,
 960                                                                                          localcoolingtubevect[0][1]->Y(),
 961                                                                                          localcoolingtubevect[0][1]->Z());
 962   localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 963                                                   -     fgkCarbonFiberTriangleLength),
 964                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 965                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 966                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 967                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 968                                                   +      fgkSSDSensorCenterSupportLength
 969                                                   -      fgkSSDSensorCenterSupportThickness[0])
 970                                                   +  fgkSSDModuleStiffenerPosition[1]
 971                                                   -  0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
 972                                                   -  0.5*fgkCoolingTubeSupportHeight);
 973   localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
 974                                                          +                               fgkCarbonFiberTriangleLength,
 975                                                                                          localcoolingtubevect[2][0]->Y(),
 976                                                                                          localcoolingtubevect[2][0]->Z());
 977   localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 978                                                   -     fgkCarbonFiberTriangleLength),
 979                                                   - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 980                                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 981                                                   +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 982                                                   -      0.5*(fgkCarbonFiberLowerSupportWidth
 983                                                   +      fgkSSDSensorCenterSupportLength
 984                                                   -      fgkSSDSensorCenterSupportThickness[0])
 985                                                   +      fgkSSDSensorLength
 986                                                   -      0.5*fgkSSDModuleStiffenerPosition[1],
 987                                                   -  0.5*fgkCoolingTubeSupportHeight);
 988   localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
 989                                                   + fgkCarbonFiberTriangleLength,
 990                                                         localcoolingtubevect[3][0]->Y(),
 991                                                   - 0.5*fgkCoolingTubeSupportHeight);
 992   for(Int_t i=0; i<4; i++)
 993         for(Int_t j=0; j<2; j++){
 994                 localcoolingtubetrans[i][j] =
 995                         new TGeoTranslation(localcoolingtubevect[i][j]->X(),
 996                                                                 localcoolingtubevect[i][j]->Y(),
 997                                                                 localcoolingtubevect[i][j]->Z());
 998                 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
 999                                                           *                                     (*localcoolingtuberot));
1000         }
1001   /////////////////////////////////////////////////////////////
1002   // SSD End Ladder Cooling Tube Transformations
1003   /////////////////////////////////////////////////////////////
1004   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1005   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1006   TGeoTranslation** localendlladdercoolingtubetrans[2];
1007   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1008   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1009   for(Int_t i=0; i<2; i++)
1010         for(Int_t j=0; j<(i==0?6:4); j++)
1011                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1012   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1013                                                                         -        fgkCoolingTubeSupportRmax)
1014                                                                         +        fgkCarbonFiberJunctionLength,
1015                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1016                                                                         -    fgkendladdercoolingsupportdistance[0]),
1017                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1018   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1019                                                                         -        fgkCoolingTubeSupportRmax)
1020                                                                         -        fgkCarbonFiberJunctionLength
1021                                                                         +    fgkCarbonFiberTriangleLength,
1022                                                                           0.5*(fgkEndLadderMountingBlockPosition[0]
1023                                                                         -    fgkendladdercoolingsupportdistance[0]),
1024                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1025   localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1026                                                                         -   fgkCoolingTubeSupportRmax)
1027                                                                         +       fgkCarbonFiberJunctionLength,
1028                                                                            fgkEndLadderMountingBlockPosition[0]
1029                                                                         -   fgkendladdercoolingsupportdistance[0]
1030                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1031                                                   +                             fgkendladdercoolingsupportdistance[1]
1032                                                   +                             fgkCoolingTubeSupportWidth),
1033                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1034   localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1035                                                                         -        fgkCoolingTubeSupportRmax)
1036                                                                         -        fgkCarbonFiberJunctionLength
1037                                                                         +    fgkCarbonFiberTriangleLength,
1038                                                                            fgkEndLadderMountingBlockPosition[0]
1039                                                                         -   fgkendladdercoolingsupportdistance[0]
1040                                                   +                0.5*(fgkendladdercoolingsupportdistance[0]
1041                                                   +                             fgkendladdercoolingsupportdistance[1]
1042                                                   +                             fgkCoolingTubeSupportWidth),
1043                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1044   localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1045                                                                         -   fgkCoolingTubeSupportRmax)
1046                                                                         +       fgkCarbonFiberJunctionLength,
1047                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1048                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1049                                                   -                     fgkEndLadderMountingBlockPosition[0]
1050                                                   -                     fgkendladdercoolingsupportdistance[1]
1051                                                   -                     fgkCoolingTubeSupportWidth),
1052                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1053   localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1054                                                                         -        fgkCoolingTubeSupportRmax)
1055                                                                         -        fgkCarbonFiberJunctionLength
1056                                                                         +    fgkCarbonFiberTriangleLength,
1057                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[0]
1058                                                   - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1059                                                   -                     fgkEndLadderMountingBlockPosition[0]
1060                                                   -                     fgkendladdercoolingsupportdistance[1]
1061                                                   -                     fgkCoolingTubeSupportWidth),
1062                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1063   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1064                                                                         -   fgkCoolingTubeSupportRmax)
1065                                                                         +       fgkCarbonFiberJunctionLength,
1066                                                         - 0.50 * (fgkMountingBlockToSensorSupport
1067                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1068                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1069                                                         +                 fgkSSDSensorOverlap
1070                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1071                                                         -                 fgkendladdercoolingsupportdistance[2]
1072                                                         -                 fgkEndLadderMountingBlockPosition[1]
1073                                                         -                 fgkCoolingTubeSupportWidth)
1074                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1075                                                         -                 fgkendladdercoolingsupportdistance[2]
1076                                                         -                 fgkCoolingTubeSupportWidth,
1077                                                   -             0.5*fgkCoolingTubeSupportHeight);
1078   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1079                                                   -      fgkCoolingTubeSupportRmax)
1080                                                   -      fgkCarbonFiberJunctionLength
1081                                                   +    fgkCarbonFiberTriangleLength,
1082                                                   - 0.50 * (fgkMountingBlockToSensorSupport
1083                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1084                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1085                                                         +                 fgkSSDSensorOverlap
1086                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1087                                                         -                 fgkendladdercoolingsupportdistance[2]
1088                                                         -                 fgkEndLadderMountingBlockPosition[1]
1089                                                         -                 fgkCoolingTubeSupportWidth)
1090                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1091                                                         -                 fgkendladdercoolingsupportdistance[2]
1092                                                         -                 fgkCoolingTubeSupportWidth,
1093                                                   -             0.5*fgkCoolingTubeSupportHeight);
1094   localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1095                                                                         -   fgkCoolingTubeSupportRmax)
1096                                                                         +       fgkCarbonFiberJunctionLength,
1097                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1098                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1099                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1100   localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1101                                                                         -        fgkCoolingTubeSupportRmax)
1102                                                                         -        fgkCarbonFiberJunctionLength
1103                                                                         +    fgkCarbonFiberTriangleLength,
1104                                                                                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1105                                                                         - 0.5*fgkendladdercoolingsupportdistance[2],
1106                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1107   fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1108   fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1109   for(Int_t i=0; i<2; i++)
1110         for(Int_t j=0; j<(i==0?6:4); j++){
1111                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1112                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1113         }
1114   /////////////////////////////////////////////////////////////
1115   // SSD Hybrid Components Transformations
1116   /////////////////////////////////////////////////////////////
1117   const Int_t khybridmatrixnumber = 3;
1118   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1119   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1120                                             0.5*fgkSSDStiffenerWidth,
1121                                             0.5*fgkSSDStiffenerHeight);
1122   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1123                                             fgkSSDModuleStiffenerPosition[1],0.0);
1124
1125   localhybridtrans[2] = new TGeoTranslation(
1126                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1127                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1128                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1129                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1130                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1131                       -       fgkSSDSensorCenterSupportThickness[0]),
1132                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1133                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1134   fhybridmatrix = new TGeoHMatrix();
1135   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1136   /////////////////////////////////////////////////////////////
1137   // SSD Cooling Block Transformations
1138   /////////////////////////////////////////////////////////////
1139   const Int_t kcoolingblockmatrixnumber = 4;
1140   TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1141   localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1142                             -  fgkCoolingTubeSupportRmin),0.0,
1143                                0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1144   localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1145                             -  0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1146                                0.0,fgkSSDStiffenerHeight);
1147   localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1148   localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1149   fcoolingblocksystematrix = new TGeoHMatrix();
1150   for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1151       fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1152   /////////////////////////////////////////////////////////////
1153   // SSD Stiffener Flex Transformations
1154   /////////////////////////////////////////////////////////////
1155   const Int_t klocalflexmatrixnumber = 4;
1156   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1157   for(Int_t i=0; i<fgkflexnumber; i++)
1158       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1159   for(Int_t i=0; i<fgkflexnumber; i++)
1160       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1161             localflexmatrix[i][j] = new TGeoCombiTrans();
1162   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1163                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1164                                                                   -    fgkSSDStiffenerWidth;
1165   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1166                                         +0.5*fgkSSDStiffenerLength,
1167                                          0.5*fgkSSDStiffenerWidth,
1168                                         -0.5*fgkSSDStiffenerHeight
1169                                         -0.5*fgkSSDFlexHeight[0]);
1170   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1171                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1172                                         -0.5*fgkSSDStiffenerWidth,
1173                                         -0.5*fgkSSDStiffenerHeight
1174                                         -0.5*fgkSSDFlexHeight[0]);
1175   TGeoRotation* localflexrot = new TGeoRotation();
1176   localflexrot->SetAngles(180.,0.,0.);
1177   localflexmatrix[1][0]->SetRotation(localflexrot);
1178   for(Int_t i=0; i<fgkflexnumber; i++)
1179       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1180             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1181   for(Int_t i=0; i<fgkflexnumber; i++){
1182       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1183       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1184             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1185   }
1186   /////////////////////////////////////////////////////////////
1187   // SSD End Flex Transformations
1188   /////////////////////////////////////////////////////////////
1189   TGeoRotation* localendflexrot = new TGeoRotation();
1190   localendflexrot->SetAngles(0.0,90.0,0.0);
1191   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1192   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1193                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1194   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1195                             * TMath::DegToRad()*ssdflexradiusmax
1196                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1197                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1198   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1199                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1200                             +      fgkSSDFlexLength[2];
1201   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1202                               0.5*fgkSSDFlexWidth[0],
1203                               2.*fgkSSDStiffenerHeight
1204                             + 0.5*fgkSSDFlexHeight[0]);
1205   localendflexmatrix->SetRotation(localendflexrot);
1206   for(Int_t i=0; i<fgkflexnumber; i++)
1207       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1208   /////////////////////////////////////////////////////////////
1209   // End Ladder Carbon Fiber Junction
1210   /////////////////////////////////////////////////////////////
1211   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1212   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1213   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1214   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1215       localendladdercarbonfiberjunctionmatrix[i]
1216             = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1217       localendladdercarbonfiberjunctionrot[i]
1218             = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1219       localendladdercarbonfiberjunctiontrans[i]
1220             = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1221       fendladdercarbonfiberjunctionmatrix[i]
1222             = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1223   }
1224   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1225       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1226             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1227             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1228       }
1229   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1230       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1231           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1232   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1233       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1234                               0.0,0.0);
1235       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1236                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1237                 *                     SinD(fgkCarbonFiberTriangleAngle),
1238                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1239   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1240   }
1241   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1242   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1243   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1244   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1245       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1246       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1247       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1248       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1249             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1250       localendladdercarbonfiberjunctionglobalmatrix[i] =
1251             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1252                                *localendladdercarbonfiberjunctionglobalrot[i]);
1253   }
1254   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1255       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1256             localendladdercarbonfiberjunctionmatrix[i][j] =
1257                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1258                                      *localendladdercarbonfiberjunctionrot[i][j]);
1259            fendladdercarbonfiberjunctionmatrix[i][j] =
1260             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1261             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1262       }
1263   /////////////////////////////////////////////////////////////
1264   // End Ladder Carbon Fiber Support
1265   /////////////////////////////////////////////////////////////
1266   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1267   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1268       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1269       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1270             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1271       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1272   }
1273   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1274       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1275             fendladdercarbonfibermatrix[i][j] =
1276             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1277             *(*fcarbonfibersupportmatrix[j]));
1278   /////////////////////////////////////////////////////////////
1279   // End Ladder SSD Mounting Block
1280   /////////////////////////////////////////////////////////////
1281   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1282       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1283   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1284       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1285                                 +        fgkSSDMountingBlockLength[1])
1286                                 +  0.5*fgkCarbonFiberTriangleLength,
1287                                 fgkEndLadderMountingBlockPosition[i],
1288                                 -  fgkSSDMountingBlockHeight[1]
1289                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1290   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1291   endladdermountingblockrot->SetAngles(0.,90.,0.);
1292   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1293         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1294   /////////////////////////////////////////////////////////////
1295   // End Ladder SSD Mounting Block Clip Matrix
1296   /////////////////////////////////////////////////////////////
1297   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1298         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1299
1300   TGeoRotation* localendladdercliprot = new TGeoRotation();
1301   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1302   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1303                                                                                   -     fgkSSDMountingBlockLength[1])
1304                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1305   localendladdercliprot->SetAngles(90.,180.,-90.);
1306   TGeoCombiTrans* localendladderclipcombitrans =
1307                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1308   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1309         for(Int_t j=0; j<2; j++){
1310                 fendladdermountingblockclipmatrix[i][j] =
1311                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1312                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1313         }
1314   /////////////////////////////////////////////////////////////
1315   // End Ladder Carbon Fiber Lower Support
1316   /////////////////////////////////////////////////////////////
1317   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1318       fendladderlowersupptrans[i] =
1319             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1320                         +  0.5*fgkSSDMountingBlockWidth),
1321                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1322   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1323                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1324                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1325                                                                          0.0);
1326   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1327  /////////////////////////////////////////////////////////////
1328   // Matrix for positioning Ladder into mother volume
1329   /////////////////////////////////////////////////////////////
1330   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1331   for(Int_t i=0; i<fgkladdernumber; i++)
1332         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1333   TGeoRotation* localladdermotherrot = new TGeoRotation();
1334   localladdermotherrot->SetAngles(0.,90.,0.);
1335   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1336   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1337   for(Int_t i=0; i<fgkladdernumber; i++){
1338         localladdermothertrans[i] = new TGeoTranslation(0.,
1339                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1340                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1341                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1342                                                           * fgkCarbonFiberJunctionWidth,0.);
1343         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1344                                                                                                                 *localladdermotherrot);
1345         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1346         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1347   }
1348   /////////////////////////////////////////////////////////////
1349   // Ladder Cables Matrices
1350   /////////////////////////////////////////////////////////////
1351   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1352                                              + fgkSSDFlexHeight[1];
1353   Double_t ssdladdercabletransx[3];
1354   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1355                                                   *   SinD(2.*fgkSSDFlexAngle)
1356                                                   *       CosD(2.*fgkSSDFlexAngle);
1357   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1358                                                   -     ssdladdercabletransx[0]
1359                                                   /     SinD(2.*fgkSSDFlexAngle))
1360                                                   *     CosD(fgkSSDFlexAngle);
1361   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1362                                                   *       TMath::DegToRad()*ssdflexradiusmax
1363                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1364                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1365                                                   -       fgkSSDLadderCableWidth)
1366                                                   *       CosD(2.*fgkSSDFlexAngle);
1367   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1368                                                   *     TanD(2.*fgkSSDFlexAngle),
1369                                                         ssdladdercabletransx[1]
1370                                                   *     TanD(fgkSSDFlexAngle),
1371                                                         ssdladdercabletransx[2]
1372                                                   *     TanD(2.*fgkSSDFlexAngle)};
1373   TGeoRotation* localladdercablerot[3];
1374   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1375   localladdercablerot[0]->SetAngles(90.,0.,0.);
1376   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1377   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1378                                                  *                        (*localladdercablerot[0]));
1379   ////////////////////////////////////////////
1380   // LocalLadderCableCombiTransMatrix
1381   ////////////////////////////////////////////
1382   const Int_t klocalladdersidecablesnumber = 2;
1383   const Int_t klocalladdercombitransnumber = 5;
1384   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1385   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1386          localladdercablecombitransmatrix[i] =
1387                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1388   ///////////////////////////////////////////
1389   // Left Side Ladder Cables Transformations
1390   ///////////////////////////////////////////
1391   localladdercablecombitransmatrix[0][0]  =
1392                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1393                                                 0.,0.,NULL);
1394   localladdercablecombitransmatrix[0][1] =
1395         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1396                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1397                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1398                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1399                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1400                                            + fgkSSDSensorCenterSupportLength
1401                                            - fgkSSDSensorCenterSupportThickness[0]),
1402                                            - (fgkSSDModuleCoolingBlockToSensor
1403                                            + 0.5*fgkCoolingTubeSupportHeight
1404                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1405                                            - fgkSSDChipHeight),NULL);
1406   localladdercablecombitransmatrix[0][2] =
1407                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1408                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1409   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1410                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1411                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1412                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1413                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1414                                                                                                 new TGeoRotation("",180.,0.,0.));
1415   localladdercablecombitransmatrix[0][4] =
1416                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1417                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1418                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1419                                                           0.,
1420                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1421                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1422                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1423                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1424   ///////////////////////////////////////////
1425   // Rigth Side Ladder Cables Transformations
1426   ///////////////////////////////////////////
1427   TGeoCombiTrans* localladdercablessdmodulematrix =
1428         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1429                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1430                                                                          fgkSSDStiffenerWidth,
1431                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1432   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1433    localladdercablecombitransmatrix[1][i] =
1434                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1435                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1436   ///////////////////////////////////////////
1437   // Setting LadderCableHMatrix
1438   ///////////////////////////////////////////
1439   Int_t beamaxistrans[2][3];
1440   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1441   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1442   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1443   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1444   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1445   beamaxistrans[1][2] = beamaxistrans[1][0];
1446   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1447   TGeoRotation* laddercablerot = new TGeoRotation();
1448   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1449   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1450   Double_t* laddercabletransvector;
1451   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1452         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1453         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1454   }
1455   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1456         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1457                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1458                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1459                         localladdercablehmatrix[i][j]->MultiplyLeft(
1460                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1461         }
1462                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1463                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1464                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1465                                                                          laddercabletransvector[1]
1466                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1467                                         *                                fgkCarbonFiberJunctionWidth,
1468                                                                          laddercabletransvector[2]);
1469                 laddercablecombitrans->SetRotation(*laddercablerot);
1470                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1471                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1472         }
1473     fladdercablematrix[i][2] =
1474                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1475                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1476         fladdercablematrix[i][3] =
1477                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1478                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1479   }
1480   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1481         for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1482                 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1483   ///////////////////////////////////////////
1484   // Setting Ladder HMatrix
1485   ///////////////////////////////////////////
1486   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1487                                                                                                 fgkSSDLay6SensorsNumber};
1488   for(Int_t i=0; i<fgkladdernumber; i++){
1489         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1490         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1491                 fladdermatrix[i][j] = new TGeoHMatrix();
1492                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1493                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1494                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1495         }
1496   }
1497   ///////////////////////////////////////////
1498   // Setting SSD Sensor Matrix
1499   ///////////////////////////////////////////
1500   TGeoCombiTrans* localssdsensorcombitrans[2];
1501   TGeoRotation* localssdsensorrot = new TGeoRotation();
1502   localssdsensorrot->SetAngles(0.,90.,0.);
1503   TGeoTranslation* localssdsensortrans[2];
1504   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1505   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1506                                           -             (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1507                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1508                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1509                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1510                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1511                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1512                                           -             fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
1513                                           -             fgkSSDSensorSideSupportHeight[0]));
1514   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1515                                           -        (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1516                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1517                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1518                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1519                       -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1520                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1521                                                         -fgkSSDModuleCoolingBlockToSensor);
1522   for(Int_t i=0; i<2; i++)
1523         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1524                                                                                                          *localssdsensorrot);
1525     for(Int_t i=0; i<fgkladdernumber; i++){
1526         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1527         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1528                 switch(i){
1529                         case 0: //Ladder of Layer5
1530                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1531                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1532                                                                                                 *localssdsensorcombitrans[1])));
1533                         break;
1534                         case 1: //Ladder of Layer6
1535                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1536                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1537                                                                                                 *localssdsensorcombitrans[0])));
1538                 break;
1539                 }
1540           }
1541   }
1542   //////////////////////////
1543   // Setting SSD End Ladder
1544   //////////////////////////
1545   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1546   for(Int_t i=0; i<2; i++){
1547         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1548         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1549         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1550         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1551         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1552         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1553         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1554         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1555    }
1556   /////////////////////////////////////////////////////
1557   // Setting the CombiTransformation to pass ITS center
1558   /////////////////////////////////////////////////////
1559   Double_t itscentertransz[fgklayernumber];
1560   itscentertransz[0] = fgkSSDLay5LadderLength
1561                                          - fgkLay5CenterITSPosition;
1562   itscentertransz[1] = fgkSSDLay6LadderLength
1563                                          - fgkLay6CenterITSPosition;
1564   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1565                                                    + 0.5*fgkCoolingTubeSupportHeight;
1566   TGeoRotation* itscenterrot[3];
1567   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1568   itscenterrot[0]->SetAngles(90.,180.,-90.);
1569   itscenterrot[1]->SetAngles(0.,90.,0.);
1570   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1571   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1572   for(Int_t i=0; i<fgklayernumber; i++)
1573         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1574                                                          itssensortransy,
1575                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1576                                                    - itscentertransz[i],itscenterrot[2]);
1577   TGeoRotation** locallayerrot[fgklayernumber];
1578   TGeoTranslation** locallayertrans[fgklayernumber];
1579   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1580   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1581   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1582                                          - fgkLay5CenterITSPosition);
1583   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1584                                          - fgkLay6CenterITSPosition);
1585   const Int_t kssdlayladdernumber[fgklayernumber] =
1586                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1587   for(Int_t i=0; i<fgklayernumber; i++){
1588     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1589     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1590         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1591         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1592   }
1593   Double_t layerladderangleposition[fgklayernumber] =
1594                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1595   Double_t layerradius = 0.;
1596   for(Int_t i=0; i<fgklayernumber; i++){
1597         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1598                 switch(i){
1599                         case 0: //Ladder of Layer5
1600                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1601                         break;
1602                         case 1: //Ladder of Layer6
1603                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1604                 break;
1605                 }
1606                 locallayerrot[i][j] = new TGeoRotation();
1607                 locallayertrans[i][j] = new TGeoTranslation();
1608                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1609                 locallayertrans[i][j]->SetTranslation(layerradius
1610                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1611                                                             layerradius
1612                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1613                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1614                                                                          *locallayerrot[i][j]);
1615                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1616                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1617                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1618         }
1619   }
1620   /////////////////////////////////////////////////////////////
1621   // Deallocating memory
1622   /////////////////////////////////////////////////////////////
1623   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1624         delete carbonfiberot[i];
1625         delete localcarbonfibersupportmatrix[i];
1626   }
1627   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1628      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1629        delete localcarbonfiberjunctionmatrix[i][j];
1630            delete localcarbonfiberjunctionrot[i][j];
1631            delete localcarbonfiberjunctiontrans[i][j];
1632            }
1633        delete [] localcarbonfiberjunctionmatrix[i];
1634        delete [] localcarbonfiberjunctionrot[i];
1635        delete [] localcarbonfiberjunctiontrans[i];
1636   }
1637   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1638            delete localcarbonfiberlowersupportrans[i];
1639   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1640      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1641        delete localssdsensorsupportmatrix[i][j];
1642            delete localssdsensorsupportrot[i][j];
1643            delete localssdsensorsupportrans[i][j];
1644            }
1645        delete [] localssdsensorsupportmatrix[i];
1646        delete [] localssdsensorsupportrot[i];
1647        delete [] localssdsensorsupportrans[i];
1648   }
1649   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1650         delete localcoolingtubesupportmatrix[i];
1651         delete localcoolingtubesupportrot[i];
1652         delete localcoolingtubesupportrans[i];
1653   }
1654   for(Int_t i=0; i<4; i++){
1655         for(Int_t j=0; j<2; j++){
1656                 delete localcoolingtubevect[i][j];
1657                 delete localcoolingtubetrans[i][j];
1658         }
1659         delete [] localcoolingtubevect[i];
1660         delete [] localcoolingtubetrans[i];
1661   }
1662  delete endladdermountingblockrot;
1663  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1664  for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1665  for(Int_t i=0; i<fgkflexnumber; i++){
1666       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1667             delete localflexmatrix[i][j];
1668       delete [] localflexmatrix[i];
1669  }
1670  delete localendlladdercoolingtuberot;
1671  for(Int_t i=0; i<2; i++){
1672         for(Int_t j=0; j<(i==0?6:4); j++)
1673                 delete localendlladdercoolingtubetrans[i][j];
1674         delete [] localendlladdercoolingtubetrans[i];
1675   }
1676
1677  delete localflexrot;
1678  delete localendflexrot;
1679  delete localendflexmatrix;
1680  for(Int_t i=0; i<fgkladdernumber; i++){
1681         delete localladdermothertrans[i];
1682         delete localladdermothercombitrans[i];
1683   }
1684  delete localladdermotherrot;
1685  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1686       for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1687             delete localendladdercarbonfiberjunctionmatrix[i][j];
1688             delete localendladdercarbonfiberjunctionrot[i][j];
1689             delete localendladdercarbonfiberjunctiontrans[i][j];
1690       }
1691       delete [] localendladdercarbonfiberjunctionmatrix[i];
1692       delete [] localendladdercarbonfiberjunctionrot[i];
1693       delete [] localendladdercarbonfiberjunctiontrans[i];
1694       delete localendladdercarbonfiberjunctionglobalrot[i];
1695       delete localendladdercarbonfiberjunctionglobaltrans[i];
1696       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1697  }
1698   for(Int_t i=0; i<2; i++){
1699         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1700         delete [] localendladdercooltubetrans[i];
1701   }
1702   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1703       delete localendladdercarbonfibertrans[i];
1704   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1705   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1706         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1707                 delete localladdercablecombitransmatrix[i][j];
1708                 delete []localladdercablecombitransmatrix[i];
1709   }
1710   delete localendladdercliprot;
1711   delete localendladdercliptrans;
1712   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1713         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1714                 delete localladdercablehmatrix[i][j];
1715         delete []localladdercablehmatrix[i];
1716   }
1717   delete laddercablerot;
1718   delete laddercabletrans;
1719   delete laddercablecombitrans;
1720   delete localladdercablessdmodulematrix;
1721   delete localssdsensorrot;
1722   for(Int_t i=0; i<2; i++){
1723         delete localssdsensortrans[i];
1724         delete localssdsensorcombitrans[i];
1725   }
1726   for(Int_t i=0; i<fgklayernumber; i++){
1727         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1728                 delete locallayerrot[i][j];
1729                 delete locallayertrans[i][j];
1730                 delete locallayercombitrans[i][j];
1731     }
1732         delete [] locallayerrot[i];
1733         delete [] locallayertrans[i];
1734         delete [] locallayercombitrans[i];
1735         delete localbeamaxistrans[i];
1736   }
1737   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1738   for(Int_t i=0; i<fgkladdernumber; i++){
1739         for(Int_t j=0; j<fgkladdernumber; j++)
1740                 delete ladderglobalmatrix[i][j];
1741         delete [] ladderglobalmatrix[i];
1742   }
1743   /////////////////////////////////////////////////////////////
1744   fTransformationMatrices = kTRUE;
1745 }
1746 ///////////////////////////////////////////////////////////////////////////////
1747 void AliITSv11GeometrySSD::CreateBasicObjects(){
1748   /////////////////////////////////////////////////////////////
1749   // Method generating the Objects of SSD Geometry
1750   /////////////////////////////////////////////////////////////
1751   // SSD Sensor
1752   ///////////////////////////////////
1753   SetSSDSensor();
1754   /////////////////////////////////////////////////////////////
1755   // Carbon Fiber Support
1756   /////////////////////////////////////////////////////////////
1757   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1758   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1759       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1760   /////////////////////////////////////////////////////////////
1761   // Carbon Fiber Junction
1762   /////////////////////////////////////////////////////////////
1763   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1764   /////////////////////////////////////////////////////////////
1765   // Carbon Fiber Lower Support
1766   /////////////////////////////////////////////////////////////
1767   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1768   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1769         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1770   /////////////////////////////
1771   // SSD Sensor Support
1772   /////////////////////////////
1773   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1774                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1775   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1776                                                                          fgkSSDSensorSideSupportThickness[1]};
1777   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1778         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1779                                                                                            fgkSSDSensorSideSupportHeight[i],
1780                                                                                            fgkSSDSensorSideSupportWidth,
1781                                                                                            sidesupporthickness);
1782         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1783                                                                                            fgkSSDSensorCenterSupportHeight[i],
1784                                                                                            fgkSSDSensorCenterSupportWidth,
1785                                                                                            sidesupporthickness);
1786   }
1787   /////////////////////////////////////////////////////////////
1788   // SSD Cooling Tube Support
1789   /////////////////////////////////////////////////////////////
1790   Int_t edgesnumber = 16;
1791   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1792   /////////////////////////////////////////////////////////////
1793   // SSD Hybrid
1794   /////////////////////////////////////////////////////////////
1795   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1796   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1797         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1798   /////////////////////////////////////////////////////////////
1799   // SSD Cooling Block System
1800   /////////////////////////////////////////////////////////////
1801   fssdcoolingblocksystem = GetCoolingBlockSystem();
1802    /////////////////////////////////////////////////////////////
1803   // SSD Cooling Tube
1804   /////////////////////////////////////////////////////////////
1805   TList* coolingtubelist = GetCoolingTubeList();
1806   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1807         fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
1808   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1809         fendladdercoolingtube[i] =
1810                         (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
1811   /////////////////////////////////////////////////////////////
1812   // SSD Flex
1813   /////////////////////////////////////////////////////////////
1814   fssdstiffenerflex = GetSSDStiffenerFlex();
1815   fssdendflex = GetSSDEndFlex();
1816   ///////////////////////////////////
1817   // End Ladder Carbon Fiber Junction
1818   ///////////////////////////////////
1819   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1820                                                    fendladdercarbonfiberjunction[i] =
1821                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1822   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1823     fendladdercarbonfiberjunction[i][0] =
1824                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1825     fendladdercarbonfiberjunction[i][1] =
1826                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1827   }
1828   ///////////////////////////////////
1829   // End Ladder Mounting Block
1830   ///////////////////////////////////
1831   fendladdermountingblock = GetSSDMountingBlock();
1832   ///////////////////////////////////
1833   // End Ladder Mounting Block
1834   ///////////////////////////////////
1835   fendladdermountingblockclip = GetMountingBlockClip();
1836   ///////////////////////////////////
1837   // Ladder Support
1838   ///////////////////////////////////
1839   TList* laddersupportlist = GetMountingBlockSupport(20);
1840   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1841   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1842   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1843   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1844   /////////////////////////////////////////////////////////////
1845   // Deallocating memory
1846   /////////////////////////////////////////////////////////////
1847   delete carbonfibersupportlist;
1848   delete carbonfiberlowersupportlist;
1849   delete ssdhybridcomponentslist;
1850   delete laddersupportlist;
1851   /////////////////////////////////////////////////////////////
1852   fBasicObjects = kTRUE;
1853 }
1854 /////////////////////////////////////////////////////////////////////////////////
1855 void AliITSv11GeometrySSD::SetSSDSensor(){
1856   ////////////////////////////////////////////////////////////////
1857   // Method generating SSD Sensors: it sets the private variables
1858   // fSSDSensor5, fSSDSensor6
1859   ////////////////////////////////////////////////////////////////
1860   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1861   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1862   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1863                                                 0.5*ssdsensitivewidth,
1864                                                 0.5*fgkSSDSensorHeight,
1865                                                 0.5*ssdsensitivelength);
1866   TGeoVolume* ssdsensorsensitiveLay5 =
1867         new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1868   TGeoVolume* ssdsensorsensitiveLay6 =
1869         new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1870   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1871   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1872   TGeoBBox* ssdsensorinsensitiveshape[2];
1873   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1874                                                 0.5*fgkSSDSensorInsensitiveWidth,
1875                                                 0.5*fgkSSDSensorHeight,
1876                                                 0.5*fgkSSDSensorLength);
1877   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1878                                                 0.5*ssdsensitivewidth,
1879                                                 0.5*fgkSSDSensorHeight,
1880                                                 0.5*fgkSSDSensorInsensitiveWidth);
1881   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1882                                              "SSDSensorInsensitive2"};
1883   TGeoVolume* ssdsensorinsensitive[2];
1884   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1885       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1886                      fSSDSensorMedium);
1887       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1888   }
1889   /////////////////////////////////////////////////////////////
1890   // Virtual Volume containing SSD Sensor
1891   /////////////////////////////////////////////////////////////
1892   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1893                                                                                              0.5*fgkSSDSensorWidth,
1894                                                                                              0.5*fgkSSDSensorHeight,
1895                                                                                              0.5*fgkSSDSensorLength);
1896   fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
1897                                                                                  fSSDAir);
1898   fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
1899                                                                                  fSSDAir);
1900   /////////////////////////////////////////////////////////////
1901   for(Int_t i=0; i<4; i++){
1902             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1903             ssdsensorinsensitive[1],i<2?1:2,
1904                         new TGeoTranslation(
1905                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1906       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1907                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1908       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1909             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1910             ssdsensorinsensitive[1],i<2?1:2,
1911                         new TGeoTranslation(
1912                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1913       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1914                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1915       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1916   }
1917     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1918     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1919 }
1920 ///////////////////////////////////////////////////////////////////////////////
1921 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1922   /////////////////////////////////////////////////////////////
1923   // Method generating the Carbon Fiber Support
1924   /////////////////////////////////////////////////////////////
1925   const Int_t kvertexnumber = 4;
1926   const Int_t kshapesnumber = 2;
1927   TVector3** vertexposition[kshapesnumber];
1928   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1929   Double_t carbonfibersupportxaxisEdgeproj =
1930                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1931         *       TMath::DegToRad());
1932   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1933                                  /                         fgkCarbonFiberSupportXAxisLength);
1934   /////////////////////
1935   //Vertex Positioning
1936   ////////////////////
1937   vertexposition[0][0] = new TVector3();
1938   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1939                                                                           fgkCarbonFiberSupportYAxisLength);
1940   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1941                                                                           carbonfibersupportxaxisEdgeproj
1942                                            *                      TMath::Tan(theta));
1943   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1944                                            -                      carbonfibersupportxaxisEdgeproj,
1945                                                                           fgkCarbonFiberSupportYAxisLength
1946                                            -                      vertexposition[0][2]->Y());
1947   ////////////////////////////////////////////////////
1948   //Setting the parameters for Isometry Transformation
1949   ////////////////////////////////////////////////////
1950   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1951                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1952                                                                  +      fgkCarbonFiberSupportWidth);
1953   Double_t* param = new Double_t[4];
1954   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1955   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1956                                   new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1957                                                           (GetReflection(vertexposition[0][j],param))->Y());
1958   char* carbonfibersupportshapename[kshapesnumber] =
1959                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1960   char* carbonfibersupportname[kshapesnumber] =
1961                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1962   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1963   TGeoVolume* carbonfibersupport[kshapesnumber];
1964   TList* carbonfibersupportlist = new TList();
1965   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1966   Double_t carbonfibersupportheight =
1967           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1968           *TMath::DegToRad());
1969   for(Int_t i = 0; i< kshapesnumber; i++){
1970    carbonfibersupportshape[i] =
1971                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1972                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1973    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1974                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1975    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1976    carbonfibersupportlist->Add(carbonfibersupport[i]);
1977    }
1978   /////////////////////////////////////////////////////////////
1979   // Deallocating memory
1980   /////////////////////////////////////////////////////////////
1981   for(Int_t i=0; i< kshapesnumber; i++){
1982      for(Int_t j=0; j< kvertexnumber; j++)
1983            delete vertexposition[i][j];
1984        delete [] vertexposition[i];
1985   }
1986   delete [] param;
1987   /////////////////////////////////////////////////////////////
1988    return carbonfibersupportlist;
1989 }
1990 /////////////////////////////////////////////////////////////////////////////////
1991 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1992   /////////////////////////////////////////////////////////////
1993   // Method generating SSD Carbon Fiber Junction
1994   /////////////////////////////////////////////////////////////
1995   const Int_t kvertexnumber = 6;
1996   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1997   Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1998                                                           *  TMath::DegToRad()),-1.,0.};
1999   TVector3* vertex[kvertexnumber];
2000   vertex[0] = new TVector3();
2001   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2002                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2003                         *                         TMath::DegToRad()),
2004                                                   fgkCarbonFiberJunctionEdge[0]
2005                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2006                         *                         TMath::DegToRad()));
2007   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2008                                                    fgkCarbonFiberJunctionEdge[1]);
2009   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2010   vertex[1] = GetReflection(vertex[5],reflectionparam);
2011   vertex[2] = GetReflection(vertex[4],reflectionparam);
2012   Double_t xvertexpoints[6], yvertexpoints[6];
2013   for(Int_t i=0; i<kvertexnumber; i++)
2014           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2015   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2016   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2017   carbonfiberjunctionshape->DefineSection(1,0.5*width);
2018   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2019                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2020   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2021   /////////////////////////////////////////////////////////////
2022   // Deallocating memory
2023   /////////////////////////////////////////////////////////////
2024   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2025   /////////////////////////////////////////////////////////////
2026   return carbonfiberjunction;
2027 }
2028 ////////////////////////////////////////////////////////////////////////////////
2029 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2030   /////////////////////////////////////////////////////////////
2031   // Method generating the Carbon Fiber Lower Support
2032   /////////////////////////////////////////////////////////////
2033   const Int_t kvertexnumber = 4;
2034   const Int_t kshapesnumber = 2;
2035   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2036                                                                 fgkCarbonFiberLowerSupportWidth};
2037   TVector3** vertexposition[kshapesnumber];
2038   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2039                                                  new TVector3*[kvertexnumber];
2040   //First Shape Vertex Positioning
2041   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2042   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2043                                            -            fgkCarbonFiberLowerSupportLowerLenght);
2044   vertexposition[0][2] = new TVector3();
2045   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2046   //Second Shape Vertex Positioning
2047   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2048                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
2049                                  /                              fgkCarbonFiberTriangleLength);
2050   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2051                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
2052                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2053   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2054                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
2055                                  +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
2056   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2057   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2058                                                                 fgkCarbonFiberLowerSupportVolumePosition[1]);
2059   char* carbonfiberlowersupportshapename[kshapesnumber] =
2060                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2061   char* carbonfiberlowersupportname[kshapesnumber] =
2062                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2063   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2064   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2065   TList* carbonfiberlowersupportlist = new TList();
2066   for(Int_t i = 0; i< kshapesnumber; i++){
2067         carbonfiberlowersupportshape[i] =
2068                                                                 GetArbShape(vertexposition[i],width,
2069                                                                                         fgkCarbonFiberLowerSupportHeight,
2070                                                                                         carbonfiberlowersupportshapename[i]);
2071     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2072                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2073         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2074     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2075   }
2076   /////////////////////////////////////////////////////////////
2077   // Deallocating memory
2078   /////////////////////////////////////////////////////////////
2079   for(Int_t i=0; i< kshapesnumber; i++){
2080      for(Int_t j=0; j< kvertexnumber; j++)
2081            delete vertexposition[i][j];
2082        delete [] vertexposition[i];
2083   }
2084   /////////////////////////////////////////////////////////////
2085   return carbonfiberlowersupportlist;
2086 }
2087 ///////////////////////////////////////////////////////////////////////////////
2088 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2089                                                                  Double_t width, Double_t* thickness)const{
2090   /////////////////////////////////////////////////////////////
2091   // Method generating the Sensor Support
2092   /////////////////////////////////////////////////////////////
2093         const Int_t kvertexnumber = 6;
2094         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2095     TVector3* vertexposition[kvertexnumber];
2096         vertexposition[0] = new TVector3();
2097         vertexposition[1] = new TVector3(0.0,length);
2098         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2099         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2100         vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2101         vertexposition[5] = new TVector3(vertexposition[4]->X());
2102         Double_t xvertexpoints[6], yvertexpoints[6];
2103         for(Int_t i=0; i<kvertexnumber; i++)
2104                 xvertexpoints[i] = vertexposition[i]->X(),
2105                 yvertexpoints[i] = vertexposition[i]->Y();
2106     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2107     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2108     ssdsensorsupportshape->DefineSection(1,0.5*width);
2109     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2110                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2111   /////////////////////////////////////////////////////////////
2112   // Deallocating memory
2113   /////////////////////////////////////////////////////////////
2114         for (Int_t i=0; i<kvertexnumber; i++)
2115                 delete vertexposition[i];
2116   /////////////////////////////////////////////////////////////
2117     return ssdsensorsupport;
2118 }
2119 ////////////////////////////////////////////////////////////////////////////////
2120 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2121   /////////////////////////////////////////////////////////////
2122   // Method generating the Cooling Tube Support
2123   /////////////////////////////////////////////////////////////
2124   if(nedges%2!=0) nedges--;
2125   const Int_t kvertexnumber = nedges+5;
2126   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2127                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2128   Double_t angle = 90.+phi;
2129   Double_t psi = 90.-phi;
2130   ///////////////////////////////////////
2131   // Vertex Positioning for TGeoXTru
2132   ///////////////////////////////////////
2133   TVector3** vertexposition = new TVector3*[kvertexnumber];
2134   vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2135                                                                    fgkCoolingTubeSupportRmin*SinD(angle));
2136   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2137                                                                    fgkCoolingTubeSupportRmax*SinD(angle));
2138   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2139                                                                    fgkCoolingTubeSupportRmax);
2140   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2141                                                                    fgkCoolingTubeSupportRmax);
2142   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2143                                                                     vertexposition[1]->Y());
2144   for(Int_t i=0; i<nedges; i++)
2145         vertexposition[i+5] =
2146                 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2147                                          fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2148   ///////////////////////////////////////////////////////////////////////
2149   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2150   ///////////////////////////////////////////////////////////////////////
2151   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2152   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2153   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2154   for(Int_t i=0; i<kvertexnumber; i++){
2155         xvertexpoints[i] = vertexposition[i]->X();
2156         yvertexpoints[i] = vertexposition[i]->Y();
2157   }
2158   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2159                                                                                         yvertexpoints);
2160   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2161   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2162   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2163                                                                           coolingtubesupportarcshape,
2164                                                                                   fSSDTubeHolderMedium);
2165   coolingtubesupportarc->SetLineColor(fColorG10);
2166   //////////////////////////////////////////////////////////////////////////
2167   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2168   //////////////////////////////////////////////////////////////////////////
2169   TGeoTubeSeg* coolingtubesupportsegshape =
2170                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2171                                                                                         fgkCoolingTubeSupportRmax,
2172                                                                                         0.5*fgkCoolingTubeSupportWidth,
2173                                                                                         phi,360-phi);
2174   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2175                                                                                         coolingtubesupportsegshape,
2176                                                                                         fSSDTubeHolderMedium);
2177   coolingtubesupportseg->SetLineColor(fColorG10);
2178   //////////////////////////////////////////////////////////////////////////
2179   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2180   //////////////////////////////////////////////////////////////////////////
2181   Double_t* boxorigin = new Double_t[3];
2182   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2183   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2184   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2185                                                                                  0.5*fgkCoolingTubeSupportHeight,
2186                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2187   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2188                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2189   coolingtubesupportbox->SetLineColor(fColorG10);
2190   //////////////////////////////////////////////////////////////////////////
2191   // Cooling Tube for Cooling Tube Support
2192   //////////////////////////////////////////////////////////////////////////
2193   TGeoXtru* coolingtubearcshape[2];
2194   coolingtubearcshape[0] = new TGeoXtru(2);
2195   Double_t* xvert = new Double_t[nedges+2];
2196   Double_t* yvert = new Double_t[nedges+2];
2197   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2198   ////////////////////////////////////////
2199   // Positioning the vertices for TGeoXTru
2200   ////////////////////////////////////////
2201   xvert[0] = 0., yvert[0] = 0.;
2202   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2203   for(Int_t i=0; i< nedges; i++)
2204                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2205                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2206   ////////////////////////////////////////
2207   // Defining TGeoXTru PolyGone
2208   ////////////////////////////////////////
2209   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2210   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2211   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2212   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2213                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2214   TGeoVolume* coolingtubearc[2];
2215   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2216                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2217   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2218                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2219   coolingtubearc[0]->SetLineColor(fColorWater);
2220   coolingtubearc[1]->SetLineColor(fColorPhynox);
2221   ////////////////////////////////////////////
2222   // Defining TGeoTubeSeg Part of Cooling Tube
2223   ////////////////////////////////////////////
2224   TGeoTubeSeg* coolingtubesegshape[2];
2225   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2226                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2227   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2228                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2229   TGeoVolume* coolingtubeseg[2];
2230   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2231                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2232   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2233                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2234   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2235   coolingtubeseg[1]->SetLineColor(fColorWater);
2236   /////////////////////////////////////////////////////////////
2237   // Virtual Volume containing Cooling Tube Support
2238   /////////////////////////////////////////////////////////////
2239   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2240   const Int_t kvirtualvertexnumber = 8;
2241   TVector3* virtualvertex[kvirtualvertexnumber];
2242    ////////////////////////////////////////
2243   // Positioning the vertices for TGeoXTru
2244   ////////////////////////////////////////
2245   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2246   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2247   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2248   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2249   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2250   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2251   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2252   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2253   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2254   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2255         xmothervertex[i] = virtualvertex[i]->X(),
2256         ymothervertex[i] = virtualvertex[i]->Y();
2257   ////////////////////////////////////////
2258   // Defining TGeoXTru PolyGone
2259   ////////////////////////////////////////
2260   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2261                                                                                                                                          ymothervertex);
2262   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2263   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2264   TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2265                                                                  virtualCoolingTubeSupportShape,fSSDAir);
2266   ////////////////////////////////////////
2267   // Positioning Volumes in Virtual Volume
2268   ////////////////////////////////////////
2269   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2270   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2271   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2272   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2273   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2274   virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2275   virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2276   virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2277   virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2278   /////////////////////////////////////////////////////////////
2279   // Deallocating memory
2280   /////////////////////////////////////////////////////////////
2281   delete [] vertexposition;
2282   delete xvertexpoints;
2283   delete yvertexpoints;
2284   delete xvert;
2285   delete yvert;
2286   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2287         delete virtualvertex[i];
2288   /////////////////////////////////////////////////////////////
2289         return virtualcoolingtubesupport;
2290 }
2291 /////////////////////////////////////////////////////////////////////////////////
2292 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2293   /////////////////////////////////////////////////////////////
2294   // Method generating List containing SSD Hybrid Components
2295   /////////////////////////////////////////////////////////////
2296   TList* ssdhybridlist = new TList();
2297   const Int_t kssdstiffenernumber = 2;
2298   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2299                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2300                                                                   -    fgkSSDStiffenerWidth;
2301   Double_t ssdchipcablesradius[kssdstiffenernumber];
2302   for(Int_t i=0; i<kssdstiffenernumber; i++)
2303           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2304                                -  fgkSSDChipCablesHeight[0]
2305                                -  fgkSSDChipCablesHeight[1]);
2306   /////////////////////////////////////////////////////////////
2307   // Mother Volumes Containers
2308   /////////////////////////////////////////////////////////////
2309   const Int_t kmothernumber = 2;
2310   const Int_t kmothervertexnumber = 12;
2311   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2312   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2313   ///////////////////////
2314   // Setting the vertices
2315   ///////////////////////
2316   xmothervertex[0][0]  = -0.5*fgkSSDStiffenerLength;
2317   xmothervertex[0][1]  = xmothervertex[0][0];
2318   xmothervertex[0][2]  = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2319   xmothervertex[0][3]  = xmothervertex[0][2];
2320   xmothervertex[0][4]  = xmothervertex[0][0];
2321   xmothervertex[0][5]  = xmothervertex[0][4];
2322   xmothervertex[0][6]  = -xmothervertex[0][0];
2323   xmothervertex[0][7]  = xmothervertex[0][6];
2324   xmothervertex[0][8]  = -xmothervertex[0][2];
2325   xmothervertex[0][9]  = xmothervertex[0][8];
2326   xmothervertex[0][10] = xmothervertex[0][7];
2327   xmothervertex[0][11] = xmothervertex[0][10];
2328   for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2329   for(Int_t i = 0; i<kmothernumber; i++){
2330       ymothervertex[i][0]  = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2331                            + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2332       ymothervertex[i][1]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2333       ymothervertex[i][2]  = ymothervertex[i][1];
2334       ymothervertex[i][3]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2335       ymothervertex[i][4]  = ymothervertex[i][3];
2336       ymothervertex[i][5]  = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2337       ymothervertex[i][6]  = ymothervertex[i][5];
2338       ymothervertex[i][7]  = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2339       ymothervertex[i][8]  = ymothervertex[i][7];
2340       ymothervertex[i][9]  = 0.5*fgkSSDStiffenerWidth;
2341       ymothervertex[i][10] = ymothervertex[i][9];
2342       ymothervertex[i][11] = ymothervertex[i][0];
2343   }
2344   TGeoXtru* ssdhybridmothershape[kmothernumber];
2345   TGeoVolume* ssdhybridmother[kmothernumber];
2346   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2347   for(Int_t i=0; i<kmothernumber; i++){
2348       ssdhybridmothershape[i] = new TGeoXtru(2);
2349       ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2350                                           ymothervertex[i]);
2351       ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2352                                                -fgkSSDChipCablesHeight[i+2]);
2353       ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2354       ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2355                                           fSSDAir);
2356    }
2357   /////////////////////////////////////////////////////////////
2358   // SSD Stiffener
2359   /////////////////////////////////////////////////////////////
2360   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2361                                              0.5*fgkSSDStiffenerLength,
2362                                              0.5*fgkSSDStiffenerWidth,
2363                                              0.5*fgkSSDStiffenerHeight);
2364   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2365                                             fSSDStiffenerMedium);
2366   ssdstiffener->SetLineColor(fColorStiffener);
2367   TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2368   for(Int_t i=0; i<kssdstiffenernumber; i++)
2369       ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2370   /////////////////////////////////////////////////////////////
2371   // SSD Chip System
2372   /////////////////////////////////////////////////////////////
2373   TList* ssdchipsystemlist = GetSSDChipSystem();
2374   Double_t ssdchipseparation = fgkSSDSensorLength
2375                              - 2.*fgkSSDModuleStiffenerPosition[1]
2376                              - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2377                              - 0.5*fgkSSDChipWidth);
2378   Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2379                                +  fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2380   TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2381                                       - 0.5*ssdchipsystemlength,
2382                                         0.5*(ssdstiffenerseparation-ssdchipseparation),
2383                                       - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2384 ////////////////////////////
2385 // Capacitor 0603-2200 nF
2386 ///////////////////////////
2387   const Int_t knapacitor0603number = 5;
2388   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2389                                                                                          0.5*fgkSSDCapacitor0603Length,
2390                                                                                          0.5*fgkSSDCapacitor0603Width,
2391                                                                                          0.5*fgkSSDCapacitor0603Height);
2392   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2393                                              fSSDStiffener0603CapacitorMedium);
2394   capacitor0603->SetLineColor(fColorAl);
2395   for(Int_t i=0; i<kmothernumber; i++){
2396       for(Int_t j=0; j<kssdstiffenernumber; j++){
2397             ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2398             for(Int_t k=1; k<knapacitor0603number+1; k++){
2399                   ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2400                         new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2401                                              j*ssdstiffenerseparation
2402                         +                    0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2403                         +                    (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2404                         -                    0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2405             }
2406       }
2407       ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2408       ssdhybridlist->Add(ssdhybridmother[i]);
2409   }
2410 /////////////////////////////////////////////////////////////
2411 // Mother Volume Containing Capacitor Part
2412 /////////////////////////////////////////////////////////////
2413   const Int_t kcapacitormothernumber = 8;
2414   Double_t xcapacitorvertex[kcapacitormothernumber];
2415   Double_t ycapacitorvertex[kcapacitormothernumber];
2416   ///////////////////////
2417   // Setting the vertices
2418   ///////////////////////
2419   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2420   xcapacitorvertex[1] = xcapacitorvertex[0];
2421   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2422   xcapacitorvertex[3] = xcapacitorvertex[2];
2423   xcapacitorvertex[4] = xcapacitorvertex[0];
2424   xcapacitorvertex[5] = xcapacitorvertex[0];
2425   xcapacitorvertex[6] = -xcapacitorvertex[0];
2426   xcapacitorvertex[7] = xcapacitorvertex[6];
2427   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2428   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2429   ycapacitorvertex[2] = ycapacitorvertex[1];
2430   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2431   ycapacitorvertex[4] = ycapacitorvertex[3];
2432   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2433   ycapacitorvertex[6] = ycapacitorvertex[5];
2434   ycapacitorvertex[7] = ycapacitorvertex[0];
2435   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2436   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2437                                               ycapacitorvertex);
2438   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2439   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2440   TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2441                                           fSSDAir);
2442 ////////////////////////////
2443 // Connector
2444 ///////////////////////////
2445   const Int_t kssdconnectornumber = 2;
2446   TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2447   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2448   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2449                                    +  fgkSSDConnectorAlHeight};
2450   const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2451   TGeoVolume* ssdconnector[kssdconnectornumber];
2452   for(Int_t i=0; i<kssdconnectornumber; i++){
2453       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2454                                           0.5*fgkSSDConnectorWidth,
2455                                           0.5*((1-i)*fgkSSDConnectorAlHeight
2456                            +              i*fgkSSDConnectorNiHeight),
2457                              i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2458       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2459                                        i==0 ? fSSDAlTraceFlexMedium
2460                                             : fSSDStiffenerConnectorMedium);
2461       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2462   }
2463   TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2464   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2465                        +  fgkSSDConnectorPosition[0]
2466                        -  fgkSSDConnectorSeparation
2467                        -  1.5*fgkSSDConnectorLength,
2468                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2469                        -  fgkSSDConnectorPosition[1]
2470                        -  ssdconnectorshape[0]->GetDY(),0.0);
2471   ssdconnectortrans[1] = new TGeoTranslation(
2472                        -  ssdstiffenershape->GetDX()
2473                        +  fgkSSDConnectorPosition[0]
2474                        -  0.5*fgkSSDConnectorLength,
2475                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2476                        -  fgkSSDConnectorPosition[1]
2477                        -  ssdconnectorshape[0]->GetDY(),0.0);
2478   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2479                        -  fgkSSDConnectorPosition[0]
2480                        +  fgkSSDConnectorSeparation
2481                        +  1.5*fgkSSDConnectorLength,
2482                           -(ssdstiffenershape->GetDY()
2483                        -  fgkSSDConnectorPosition[1]
2484                        -  ssdconnectorshape[0]->GetDY()),0.0);
2485   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2486                        -  fgkSSDConnectorPosition[0]
2487                        +  0.5*fgkSSDConnectorLength,
2488                           -(ssdstiffenershape->GetDY()
2489                        -  fgkSSDConnectorPosition[1]
2490                        -  ssdconnectorshape[0]->GetDY()),0.0);
2491   for(Int_t i=0; i<2*kssdconnectornumber; i++)
2492       for(Int_t j=0; j<kssdconnectornumber; j++)
2493             ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2494 ////////////////////////////
2495 // Capacitor 1812-330 nF
2496 ///////////////////////////
2497   Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2498   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2499                                                                                          0.5*fgkSSDCapacitor1812Length,
2500                                                                                          0.5*fgkSSDCapacitor1812Width,
2501                                                                                          0.5*fgkSSDCapacitor1812Height,
2502             ssdcapacitor1812origin);
2503   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2504                                              fSSDStiffener1812CapacitorMedium);
2505   capacitor1812->SetLineColor(fColorAl);
2506   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2507                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2508                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2509   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2510 ////////////////////////////
2511 //Hybrid Wire
2512 ////////////////////////////
2513   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2514                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2515                                  - fgkSSDConnectorSeparation;
2516   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2517                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2518   Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2519                                          + TMath::Power(wirey,2));
2520   Double_t wireangle = TMath::ATan(wirex/wirey);
2521   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2522                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2523   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2524                                              fSSDStiffenerHybridWireMedium);
2525   hybridwire->SetLineColor(fColorPhynox);
2526   TGeoCombiTrans* hybridwirecombitrans[2];
2527   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2528                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2529                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2530                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2531                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2532                                    ssdstiffenershape->GetDZ()
2533                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
2534                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2535   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2536                             0.0,
2537                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2538                             0.0,
2539                             new TGeoRotation("HybridWireRot2",
2540                           - wireangle*TMath::RadToDeg(),0.,0.));
2541   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2542   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2543   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2544   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2545   ssdhybridlist->Add(ssdhybridcapacitormother);
2546   /////////////////////////////////////////////////////////////
2547   // Deallocating memory
2548   /////////////////////////////////////////////////////////////
2549   delete hybridwirecombitrans[0];
2550   delete hybridwirecombitrans[1];
2551   delete ssdchipsystemlist;
2552   return ssdhybridlist;
2553   /////////////////////////////////////////////////////////////
2554 }
2555 ///////////////////////////////////////////////////////////////////////////////
2556 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2557   /////////////////////////////////////////////////////////////
2558   // SSD Cooling Block System
2559   /////////////////////////////////////////////////////////////
2560   // SSD Cooling Block and Cooling Tube Transformations
2561   /////////////////////////////////////////////////////////////
2562   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2563   localcoolingblockrot->SetAngles(0.,90.,0.);
2564   TGeoCombiTrans* localcoolingblockmatrix =
2565         new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2566   TGeoTranslation* localcoolingblocktrans;
2567   TVector3* coolingblocktransvector;
2568   coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2569                                                                 + fgkSSDCoolingBlockLength,
2570                                                                   fgkSSDSensorLength
2571                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2572                                                                 - fgkSSDCoolingBlockWidth);
2573   const Int_t kcoolingblocktransnumber = 2;
2574   const Int_t kcoolingblocknumber = 4;
2575   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2576   TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2577   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2578   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2579   TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2580   localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2581                                                                                 0.5*fgkSSDCoolingBlockWidth,
2582                                                                                         fgkSSDCoolingBlockHoleCenter);
2583   TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2584                                                                                                                           *localcoolingtuberot);
2585   Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2586   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2587           for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2588                 localcoolingblocktrans=
2589                      new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2590                                                                  j*coolingblocktransvector->Y(),
2591                                                                  - 0.5*(fgkSSDCoolingBlockHoleCenter
2592                                                              + fgkCoolingTubeRmax));
2593                 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2594                                                                  *(*localcoolingblockmatrix));
2595                 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2596                                                                  *(*localcoolingtubematrix));
2597         }
2598   }
2599   /////////////////////////////////////////////////////////////
2600   // Virtual Volume containing CoolingBlock System
2601   /////////////////////////////////////////////////////////////
2602   TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2603   const Int_t kmothervertexnumber = 16;
2604   Double_t xmothervertex[kmothervertexnumber];
2605   Double_t ymothervertex[kmothervertexnumber];
2606   ///////////////////////
2607   // Setting the vertices
2608   ///////////////////////fgkCoolingTubeSupportRmax
2609   xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2610   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2611                                    + fgkSSDCoolingBlockWidth;
2612   xmothervertex[2] = coolingblocktransvector->X()
2613                                    + fgkSSDCoolingBlockLength
2614                                    + 4*coolingtubedistance;
2615   ymothervertex[2] = ymothervertex[1];
2616   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2617   xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2618   ymothervertex[4] = ymothervertex[0];
2619   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2620   xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2621   ymothervertex[6] = ymothervertex[5];
2622   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2623                                    - fgkSSDCoolingBlockWidth;
2624   xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2625   xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2626                                    - coolingtubedistance;
2627   xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2628   ymothervertex[10] = ymothervertex[9];
2629   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2630   xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2631   xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2632   xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2633   ymothervertex[14] = ymothervertex[13];
2634   xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2635   //////////////////////////////////////////////////////////
2636   coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2637                                                                         xmothervertex,ymothervertex);
2638   coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2639                                                                                            + fgkCoolingTubeRmax));
2640   coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2641                                                                                            + fgkCoolingTubeRmax));
2642   TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2643                                                           coolingsystemothershape,fSSDAir);
2644   /////////////////////////////////////////////////////////////
2645   // SSD Cooling Tube Part
2646   /////////////////////////////////////////////////////////////
2647   TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2648   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2649                                                                                  0.5*fgkSSDCoolingBlockWidth);
2650   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2651                                                                          0.5*fgkSSDCoolingBlockWidth);
2652   TGeoVolume* coolingtube[fgkcoolingtubenumber];
2653   coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2654                                                                         fSSDCoolingTubePhynox);
2655   coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2656                                                                         fSSDCoolingTubeWater);
2657   coolingtube[0]->SetLineColor(fColorPhynox);
2658   coolingtube[1]->SetLineColor(fColorWater);
2659   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2660   /////////////////////////////////////////////////////////////
2661   // Adding Cooling block to mother volume
2662   /////////////////////////////////////////////////////////////
2663    for(Int_t i=0; i<kcoolingblocknumber; i++){
2664         coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2665         coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2666         coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
2667   }
2668   /////////////////////////////////////////////////////////////
2669   // Deallocating memory
2670   /////////////////////////////////////////////////////////////
2671         delete coolingblocktransvector;
2672     delete localcoolingblocktrans;
2673         delete localcoolingblockrot;
2674         delete localcoolingblockmatrix;
2675         delete localcoolingtubetrans;
2676         delete localcoolingtuberot;
2677   /////////////////////////////////////////////////////////////
2678   // Checking overlaps
2679   /////////////////////////////////////////////////////////////
2680         //coolingsystemother->CheckOverlaps(0.01);
2681   /////////////////////////////////////////////////////////////
2682         return coolingsystemother;
2683 }
2684 /////////////////////////////////////////////////////////////////////////////////
2685 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2686   /////////////////////////////////////////////////////////////
2687   // SSD Flex
2688   /////////////////////////////////////////////////////////////
2689   const Int_t kssdflexlayernumber = 2;
2690   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2691   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2692   const Int_t kmothervertexnumber = 17;
2693   Double_t xmothervertex[kmothervertexnumber];
2694   Double_t ymothervertex[kmothervertexnumber];
2695   /////////////////////////////////////////////
2696   // Auxiliary variables for vertex positioning
2697   /////////////////////////////////////////////
2698   const Int_t kssdflexboxnumber = 5;
2699   Double_t ssdflexboxlength[kssdflexboxnumber];
2700   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2701                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2702                                           *     fgkSSDChipSeparationLength
2703                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2704                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2705   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2706   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2707                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2708   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2709   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2710                                           -     ssdflexboxlength[1];
2711   Double_t ssdflexboxwidth[kssdflexboxnumber];
2712   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2713   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2714   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2715   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2716   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2717   ///////////////////////
2718   // Setting the vertices
2719   ///////////////////////
2720   xmothervertex[0]  = 0.0;
2721   xmothervertex[1]  = xmothervertex[0];
2722   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2723   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2724                                         + ssdflexboxlength[4];
2725   xmothervertex[4]  = xmothervertex[3];
2726   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2727   xmothervertex[6]  = xmothervertex[5];
2728   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2729   xmothervertex[8]  = xmothervertex[7];
2730   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2731   xmothervertex[10] = xmothervertex[9];
2732   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2733   xmothervertex[12] = xmothervertex[11];
2734   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2735   xmothervertex[14] = xmothervertex[13];
2736   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2737   xmothervertex[16] = xmothervertex[15];
2738   ymothervertex[0]  = 0.0;
2739   ymothervertex[1]  = fgkSSDFlexWidth[1];
2740   ymothervertex[2]  = fgkSSDFlexWidth[0];
2741   ymothervertex[3]  = ymothervertex[2];
2742   ymothervertex[4]  = ymothervertex[0];
2743   ymothervertex[5]  = ymothervertex[4];
2744   ymothervertex[6]  = ssdflexboxwidth[2];
2745   ymothervertex[7]  = ymothervertex[6];
2746   ymothervertex[8]  = ymothervertex[0];
2747   ymothervertex[9]  = ymothervertex[8];
2748   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2749   ymothervertex[11] = ymothervertex[10];
2750   ymothervertex[12] = ymothervertex[0];
2751   ymothervertex[13] = ymothervertex[12];
2752   ymothervertex[14] = ymothervertex[7];
2753   ymothervertex[15] = ymothervertex[14];
2754   ymothervertex[16] = ymothervertex[0];
2755   /////////////////////////////////////////////////////////////
2756   // First Mother Volume containing SSDFlex
2757   /////////////////////////////////////////////////////////////
2758   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2759   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2760                                                                     ymothervertex);
2761   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2762   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2763   TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2764                                                                                          fSSDAir);
2765   /////////////////////////////////////////////////////////////
2766   // SSDFlex Layer Shapes
2767   /////////////////////////////////////////////////////////////
2768   for(Int_t i=0; i<kssdflexlayernumber; i++){
2769         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2770                                                                    ymothervertex);
2771     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2772         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2773   }
2774   /////////////////////////////////////
2775   // Setting Layers into Mother Volume
2776   /////////////////////////////////////
2777   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2778   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2779                                                                                                  fSSDKaptonFlexMedium};
2780   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2781                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2782   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2783   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2784   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2785         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2786                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2787                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2788         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2789     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2790                                          +                                         fgkSSDFlexHeight[1]));
2791     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2792   }
2793   //ssdflexmother->CheckOverlaps(0.01);
2794   return ssdflexmother;
2795 }
2796 /////////////////////////////////////////////////////////////////////////////////
2797 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2798   /////////////////////////////////////////////////////////////
2799   // Method generating SSD End Flex
2800   /////////////////////////////////////////
2801   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2802                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2803   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2804                                                 * TMath::DegToRad()*ssdflexradiusmax
2805                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2806                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2807   const Int_t knedges = 20;
2808   const Int_t karcnumber = 2;
2809   TVector3* vertexposition[karcnumber*(knedges+1)];
2810   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2811   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2812   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2813   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2814                                                                                  - 90.0*TMath::DegToRad()};
2815   TVector3* referencetrans[karcnumber];
2816   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2817                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2818                                                                    radius[0]);
2819   referencetrans[1] = new TVector3(referencetrans[0]->X()
2820                                         +              fgkSSDFlexLength[2],
2821      -              fgkSSDStiffenerHeight);
2822 for(Int_t i=0; i<karcnumber; i++){
2823         for(Int_t j=0; j<knedges+1; j++){
2824                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2825                                                                                                radius[i]*SinD(angle[i]));
2826                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2827         }
2828   }
2829   ///////////////////////
2830   // Setting the vertices
2831   ///////////////////////
2832   const Int_t kendflexlayernumber = 4;
2833   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2834   TVector3** vertex[kendflexlayernumber];
2835   for(Int_t i=0; i<kendflexlayernumber; i++)
2836                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2837   TVector3* transvector[kendflexlayernumber+1];
2838   TVector3* deltatransvector = new TVector3();
2839   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2840   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2841                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2842   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2843         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2844                                         *                 CosD(fgkSSDFlexAngle),
2845                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2846                                         *         SinD(fgkSSDFlexAngle),0.0);
2847         *transvector[i] = *transvector[i-1]+*deltatransvector;
2848   }
2849   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2850   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2851   for(Int_t i=0; i<karcnumber; i++){
2852         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2853                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2854                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2855                                               /radius[i];
2856         }
2857   }
2858   for(Int_t i=0; i<kendflexlayernumber; i++){
2859         vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2860         vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2861         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2862                 if(j<(knedges+1)){
2863                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2864                                                                                   vertexposition[j]->Y()*ratioradius[0][i+1]);
2865                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2866                         *vertex[i][j+2] += *referencetrans[0];
2867                         vertex[i][4*(knedges+1)-j+1] =
2868                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2869                                                                                   vertexposition[j]->Y()*ratioradius[0][i]);
2870                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2871                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2872                 }
2873                 else{
2874
2875                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2876                                                                                   vertexposition[j]->Y()*ratioradius[1][i+1]);
2877                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2878                         *vertex[i][j+2] += *referencetrans[1];
2879                         vertex[i][4*(knedges+1)-j+1] =
2880                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2881                                                                                   vertexposition[j]->Y()*ratioradius[1][i]);
2882                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2883                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2884            }
2885         }
2886   }
2887   /////////////////////////////////////////////////////////////
2888   // First Mother Volume containing SSDEndFlex
2889   /////////////////////////////////////////////////////////////
2890   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2891   Double_t xmothervertex[kendflexvertexnumber];
2892   Double_t ymothervertex[kendflexvertexnumber];
2893   xmothervertex[0] = vertex[0][0]->X();
2894   ymothervertex[0] = vertex[0][0]->Y();
2895   for(Int_t i=1; i<kendflexvertexnumber; i++){
2896         if(i<2*(knedges+1)+2){
2897                 xmothervertex[i] = vertex[3][i]->X();
2898                 ymothervertex[i] = vertex[3][i]->Y();
2899         }
2900         else{
2901                 xmothervertex[i] = vertex[0][i]->X();
2902                 ymothervertex[i] = vertex[0][i]->Y();
2903         }
2904   }
2905   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2906                                                                            xmothervertex,ymothervertex);
2907   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2908   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2909   TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2910                                                                  ssdendflexmothershape,fSSDAir);
2911   //////////////////////////////////////
2912   // End Flex TGeoXtru Layer Definition
2913   //////////////////////////////////////
2914   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2915   TGeoVolume* ssdendflex[kendflexlayernumber];
2916   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2917   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2918   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2919   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2920   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2921                                                                                                         fSSDKaptonFlexMedium};
2922   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2923                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2924   for(Int_t i=0; i<kendflexlayernumber; i++){
2925         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2926                 xvertex[i][j] = vertex[i][j]->X();
2927                 yvertex[i][j] = vertex[i][j]->Y();
2928         }
2929   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2930   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2931   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2932   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2933                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2934   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2935   ssdendflexmother->AddNode(ssdendflex[i],1);
2936   }
2937   /////////////////////////////////////////////////////////////
2938   // Deallocating memory
2939   /////////////////////////////////////////////////////////////
2940   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2941   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2942   for(Int_t i=0; i<kendflexlayernumber; i++){
2943         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2944         delete [] vertex[i];
2945   }
2946   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2947   delete deltatransvector;
2948   /////////////////////////////////////////////////////////////
2949   //ssdendflexmother->CheckOverlaps(0.01);
2950   return ssdendflexmother;
2951 }
2952 ///////////////////////////////////////////////////////////////////////////////
2953 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2954   /////////////////////////////////////////////////////////////
2955   // Method generating the Mounting Block
2956   /////////////////////////////////////////////////////////////
2957   const Int_t kvertexnumber = 8;
2958   Double_t xvertex[kvertexnumber];
2959   Double_t yvertex[kvertexnumber];
2960   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2961   xvertex[1] = xvertex[0];
2962   xvertex[2] = -xvertex[0];
2963   xvertex[3] = xvertex[2];
2964   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2965                          -                                 fgkSSDMountingBlockLength[2]);
2966   xvertex[5] = xvertex[4];
2967   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2968                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2969                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2970   xvertex[7] = xvertex[6];
2971   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2972                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2973   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2974   yvertex[2] = yvertex[1];
2975   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2976   yvertex[4] = yvertex[3];
2977   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2978                          - fgkSSDMountingBlockHeight[0];
2979   yvertex[6] = yvertex[5];
2980   yvertex[7] = yvertex[0];
2981   ///////////////////////////////////////////////////////////////////////
2982   // TGeoXTru Volume definition for Mounting Block Part
2983   ///////////////////////////////////////////////////////////////////////
2984   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2985   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2986   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2987   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2988   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2989                                                                           ssdmountingblockshape,
2990                                                                                   fSSDMountingBlockMedium);
2991   ssdmountingblock->SetLineColor(fColorG10);
2992   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2993   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2994   TGeoRotation* mountingblockrot = new TGeoRotation();
2995   mountingblockrot->SetAngles(90.,180.,-90.);
2996   mountingblockcombitrans->SetRotation(*mountingblockrot);
2997   /////////////////////////////////////////////////////////////
2998   // Generating the Mounting Block Screw Vertices
2999   /////////////////////////////////////////////////////////////
3000   const Int_t kscrewvertexnumber = 15;
3001   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3002                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
3003                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
3004                                  * TMath::RadToDeg();
3005   Double_t phi0 = 90.+alpha;
3006   Double_t phi = 270.-2*alpha;
3007   Double_t deltaphi = phi/kscrewvertexnumber;
3008   TVector3* screwvertex[kscrewvertexnumber+1];
3009   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3010         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3011                                    *CosD(phi0+i*deltaphi),
3012                                    fgkSSDMountingBlockScrewHoleRadius[0]
3013                                    *SinD(phi0+i*deltaphi));
3014   Double_t xscrewvertex[kscrewvertexnumber+6];
3015   Double_t yscrewvertex[kscrewvertexnumber+6];
3016   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3017   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3018                                   -               fgkSSDMountingBlockScrewHoleEdge);
3019   xscrewvertex[1] = xscrewvertex[0];
3020   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3021   xscrewvertex[2] = screwvertex[0]->X();
3022   yscrewvertex[2] = yscrewvertex[1];
3023   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3024         xscrewvertex[i+3] = screwvertex[i]->X();
3025         yscrewvertex[i+3] = screwvertex[i]->Y();
3026   }
3027   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3028   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3029   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3030   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3031   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3032   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3033   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3034   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3035                                                         +                                  fgkSSDMountingBlockHeight[2]);
3036   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3037                                                                                 ssdmountingblockscrewshape,
3038                                                                                             fSSDMountingBlockMedium);
3039   ssdmountingblockscrew->SetLineColor(fColorG10);
3040   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3041   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3042   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3043                                                                         -                                yscrewvertex[1],
3044                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
3045                                                                         -                                fgkSSDMountingBlockHeight[2]
3046                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3047                                                                         +                                fgkSSDMountingBlockHeight[2]
3048                                                                         -                                yvertex[0]));
3049   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3050                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
3051                                                                                                                  yscrewvertex[1]
3052                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3053                                                                                                          +fgkSSDMountingBlockHeight[2]
3054                                                                                                          -yvertex[0]));
3055   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3056                                                                                                           yscrewvertex[1],
3057                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
3058                                                                         +                                 fgkSSDMountingBlockHeight[2]
3059                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3060                                                                         +                                 fgkSSDMountingBlockHeight[2]
3061                                                                         -                                 yvertex[0]));
3062   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3063                                                                                                          yscrewvertex[1],
3064                                                                         -                                yscrewvertex[1]
3065                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3066                                                                         +                                fgkSSDMountingBlockHeight[2]
3067                                                                         -                                yvertex[0]));
3068   TGeoRotation* ssdmountingblockscrewrot[4];
3069   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3070         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3071     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3072     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3073   for(Int_t i=1; i<4; i++)
3074         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3075   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3076   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3077   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3078   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3079                                                          +                                xvertex[0],yscrewvertex[1]
3080                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3081                                                          +                                fgkSSDMountingBlockHeight[2]
3082                                                          -                                yvertex[0]),0.);
3083   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3084   for(Int_t i=0; i<4; i++){
3085         ssdmountingblockscrewmatrix[i] =
3086                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3087         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3088   }
3089   ///////////////////////////////////////////////////////////////////////
3090   // TGeoXtru for Mother Volume
3091   ///////////////////////////////////////////////////////////////////////
3092   const Int_t kvertexmothernumber = 12;
3093   Double_t xmothervertex[kvertexmothernumber];
3094   Double_t ymothervertex[kvertexmothernumber];
3095   for(Int_t i=0; i<6; i++){
3096         xmothervertex[i] = xvertex[i];
3097         ymothervertex[i] = yvertex[i];
3098   }
3099   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
3100   ymothervertex[6]  = ymothervertex[5];
3101   xmothervertex[7]  = xmothervertex[6];
3102   ymothervertex[7]  = ymothervertex[4];
3103   xmothervertex[8]  = xmothervertex[7]
3104                                         + 0.5*(fgkSSDMountingBlockLength[1]
3105                                         -          fgkSSDMountingBlockLength[2]);
3106   ymothervertex[8]  = ymothervertex[4];
3107   xmothervertex[9]  = xmothervertex[8];
3108   ymothervertex[9]  = ymothervertex[2];
3109   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3110   ymothervertex[10] = ymothervertex[1];
3111   xmothervertex[11] = xmothervertex[10];
3112   ymothervertex[11] = ymothervertex[0];
3113   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3114   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3115   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3116   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3117   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3118                                                                           ssdmountingblockmothershape,
3119                                                                                   fSSDAir);
3120   /////////////////////////////////////////////////////////////
3121   // Placing the Volumes into Mother Volume
3122   /////////////////////////////////////////////////////////////
3123   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3124   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3125   for(Int_t i=0; i<4; i++)
3126         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3127                                                                         ssdmountingblockscrewmatrix[i]);
3128   /////////////////////////////////////////////////////////////
3129   // Deallocating memory
3130   /////////////////////////////////////////////////////////////
3131   delete mountingblockrot;
3132   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3133   delete ssdmountingblockglobalrot;
3134   delete ssdmountingblockglobaltrans;
3135   /////////////////////////////////////////////////////////////
3136   return ssdmountingblockmother;
3137 }
3138 ///////////////////////////////////////////////////////////////////////////////
3139  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3140   /////////////////////////////////////////////////////////////
3141   // Method generating the Mounting Block Clip
3142   /////////////////////////////////////////////////////////////
3143   const Int_t kmothervertexnumber = 10;
3144   Double_t xmothervertex[kmothervertexnumber];
3145   Double_t ymothervertex[kmothervertexnumber];
3146   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3147                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3148   xmothervertex[1] = xmothervertex[0];
3149   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3150                                    - fgkMountingBlockClibScrewRadius);
3151   xmothervertex[3] = xmothervertex[2];
3152   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3153   xmothervertex[5] = xmothervertex[4];
3154   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3155   xmothervertex[7] = xmothervertex[6];
3156   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3157   xmothervertex[9] = xmothervertex[8];
3158   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3159                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3160   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3161   ymothervertex[2] = ymothervertex[1];
3162   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3163                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3164                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3165   ymothervertex[4] = ymothervertex[3];
3166   ymothervertex[5] = ymothervertex[2];
3167   ymothervertex[6] = ymothervertex[5];
3168   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3169   ymothervertex[8] = ymothervertex[7];
3170   ymothervertex[9] = ymothervertex[0];
3171   ///////////////////////////////////////////////////////////////////////
3172   // TGeoXTru Volume definition for Mounting Block Clip Part
3173   ///////////////////////////////////////////////////////////////////////
3174   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3175   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3176   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3177   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3178   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3179                                                                           ssdmountingblockclipshape,fSSDAir);
3180   ssdmountingblockclip->SetLineColor(4);
3181   ///////////////////////////////////////////////////////////////////////
3182   // TGeoXTru Volume definition for Clip
3183   ///////////////////////////////////////////////////////////////////////
3184   const Int_t kclipvertexnumber = 6;
3185   Double_t xclipvertex[kclipvertexnumber];
3186   Double_t yclipvertex[kclipvertexnumber];
3187   xclipvertex[0] = xmothervertex[0];
3188   xclipvertex[1] = xclipvertex[0];
3189   xclipvertex[2] = xmothervertex[6];
3190   xclipvertex[3] = xclipvertex[2];
3191   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3192   xclipvertex[5] = xclipvertex[4];
3193   yclipvertex[0] = ymothervertex[0];
3194   yclipvertex[1] = ymothervertex[1];
3195   yclipvertex[2] = yclipvertex[1];
3196   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3197   yclipvertex[4] = yclipvertex[3];
3198   yclipvertex[5] = yclipvertex[0];
3199   TGeoXtru* clipshape = new TGeoXtru(2);
3200   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3201   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3202   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3203                                                          +   fgkMountingBlockClibWidth);
3204   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3205   clip->SetLineColor(18);
3206   ///////////////////////////////////////////////////////////////////////
3207   // Ladder Support Piece
3208   ///////////////////////////////////////////////////////////////////////
3209   const Int_t ksupportvertexnumber = 4;
3210   Double_t xsupportvertex[ksupportvertexnumber];
3211   Double_t ysupportvertex[ksupportvertexnumber];
3212   xsupportvertex[0] = xclipvertex[5];
3213   xsupportvertex[1] = xsupportvertex[0];
3214   xsupportvertex[2] = xmothervertex[9];
3215   xsupportvertex[3] = xsupportvertex[2];
3216   ysupportvertex[0] = yclipvertex[0];
3217   ysupportvertex[1] = yclipvertex[3];
3218   ysupportvertex[2] = ysupportvertex[1];
3219   ysupportvertex[3] = ysupportvertex[0];
3220   TGeoXtru* supportshape = new TGeoXtru(2);
3221   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3222   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3223   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3224   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3225   support->SetLineColor(9);
3226   ///////////////////////////////////////////////////////////////////////
3227   // TGeoXTru Volume definition for Screw
3228   ///////////////////////////////////////////////////////////////////////
3229   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3230                                                 0.5*fgkMountingBlockClibScrewRadius};
3231   Int_t edgesnumber[2] = {50,6};
3232   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3233                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3234   TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3235   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3236   clipscrew->SetLineColor(12);
3237   TGeoRotation* screwrot = new TGeoRotation();
3238   screwrot->SetAngles(0.,90.,0.);
3239   TGeoTranslation* screwtrans = new TGeoTranslation();
3240   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3241                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3242                                                          0.5*fgkSSDMountingBlockWidth+
3243                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3244   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3245   ///////////////////////////////////////////////////////////////////////
3246   // Placing the Volumes
3247   ///////////////////////////////////////////////////////////////////////
3248   ssdmountingblockclip->AddNode(clip,1);
3249   ssdmountingblockclip->AddNode(support,1);
3250   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3251   /////////////////////////////////////////////////////////////
3252   // Deallocating memory
3253   /////////////////////////////////////////////////////////////
3254   delete screwtrans;
3255   delete screwrot;
3256   /////////////////////////////////////////////////////////////
3257   return ssdmountingblockclip;
3258 }
3259 ///////////////////////////////////////////////////////////////////////////////
3260 TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
3261   /////////////////////////////////////////////////////////////
3262   // Method generating the Cooling Tube
3263   /////////////////////////////////////////////////////////////
3264    TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3265    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3266                                                                                                 new     TGeoTube*[2];
3267    // Ladder Cooling Tubes
3268    coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3269                                           0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3270                                                   -     2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3271    coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3272                                                                                  coolingtubeshape[0][0]->GetDz());
3273    coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3274                                                                                  0.5*(fgkSSDModuleStiffenerPosition[1]
3275                                                   -                                       fgkSSDSensorOverlap));
3276    coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3277                                                                                  coolingtubeshape[1][0]->GetDz());
3278    coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3279                                                                                  0.5*fgkSSDModuleStiffenerPosition[1]);
3280    coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3281                                                                                  coolingtubeshape[2][0]->GetDz());
3282    // End Ladder Cooling Tubes
3283    TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3284    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3285         endladdercoolingtubeshape[i] = new      TGeoTube*[2];
3286    endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3287                                                         0.50 * (fgkEndLadderMountingBlockPosition[0]
3288                                                   -                     fgkendladdercoolingsupportdistance[0]));
3289    endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3290                                                                         endladdercoolingtubeshape[0][0]->GetDz());
3291    endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3292                                                         0.50 * (fgkendladdercoolingsupportdistance[0]
3293                                                   +                     fgkendladdercoolingsupportdistance[1]
3294                                                   -                     fgkCoolingTubeSupportWidth));
3295    endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3296                                                                         endladdercoolingtubeshape[1][0]->GetDz());
3297    endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3298                                                         0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3299                                                   -                     fgkEndLadderMountingBlockPosition[0]
3300                                                   -                     fgkendladdercoolingsupportdistance[1]
3301                                                   -                     fgkCoolingTubeSupportWidth));
3302    endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3303                                                                         endladdercoolingtubeshape[2][0]->GetDz());
3304    endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3305                                                           0.50 * (fgkMountingBlockToSensorSupport
3306                                                         - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3307                                                         -                 fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3308                                                         +                 fgkSSDSensorOverlap
3309                                                         +                 fgkEndLadderCarbonFiberLowerJunctionLength[1]
3310                                                         -                 fgkendladdercoolingsupportdistance[2]
3311                                                         -                 fgkEndLadderMountingBlockPosition[1]
3312                                                         -                 fgkCoolingTubeSupportWidth));
3313    endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3314                                                                         endladdercoolingtubeshape[3][0]->GetDz());
3315    endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3316                                                           0.50 * fgkendladdercoolingsupportdistance[2]);
3317    endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3318                                                                         endladdercoolingtubeshape[4][0]->GetDz());
3319    // Ladder Cooling Tubes
3320    TGeoVolume** coolingtube[fgkcoolingtubenumber];
3321    for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3322                                                                                          new TGeoVolume*[2];
3323    coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3324                                                                           fSSDCoolingTubePhynox);
3325    coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3326                                                                           fSSDCoolingTubeWater);
3327    coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3328                                                                           fSSDCoolingTubePhynox);
3329    coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3330                                                                           fSSDCoolingTubeWater);
3331    coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3332                                                                           fSSDCoolingTubePhynox);
3333    coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3334                                                                           fSSDCoolingTubeWater);
3335    for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3336         coolingtube[i][0]->SetLineColor(fColorPhynox);
3337         coolingtube[i][1]->SetLineColor(fColorWater);
3338    }
3339    // End Ladder Cooling Tubes
3340    TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3341    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3342    endladdercoolingtube[i] = new TGeoVolume*[2];
3343    endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3344                                                                 endladdercoolingtubeshape[0][0],
3345                                                                 fSSDCoolingTubePhynox);
3346    endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3347                                                                 endladdercoolingtubeshape[0][1],
3348                                                                 fSSDCoolingTubeWater);
3349    endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3350                                                                 endladdercoolingtubeshape[1][0],
3351                                                                 fSSDCoolingTubePhynox);
3352    endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3353                                                                 endladdercoolingtubeshape[1][1],
3354                                                                 fSSDCoolingTubeWater);
3355    endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3356                                                                 endladdercoolingtubeshape[2][0],
3357                                                                 fSSDCoolingTubePhynox);
3358    endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3359                                                                 endladdercoolingtubeshape[2][1],
3360                                                                 fSSDCoolingTubeWater);
3361    endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3362                                                                 endladdercoolingtubeshape[3][0],
3363                                                                 fSSDCoolingTubePhynox);
3364    endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3365                                                                 endladdercoolingtubeshape[3][1],
3366                                                                 fSSDCoolingTubeWater);
3367    endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3368                                                                 endladdercoolingtubeshape[4][0],
3369                                                                 fSSDCoolingTubePhynox);
3370    endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3371                                                                 endladdercoolingtubeshape[4][1],
3372                                                                 fSSDCoolingTubeWater);
3373    for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3374         endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3375         endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3376    }
3377   /////////////////////////////////////////////////////////////
3378   // Virtual Volume containing Cooling Tubes
3379   /////////////////////////////////////////////////////////////
3380   // Ladder Cooling Tubes
3381   TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3382   for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3383   virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3384                                                                                         coolingtubeshape[i][0]->GetRmax(),
3385                                                                                         coolingtubeshape[i][0]->GetDz());
3386   TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3387   virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3388                                                                           fSSDAir);
3389   virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3390                                                                           fSSDAir);
3391   virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3392                                                                           fSSDAir);
3393   // End Ladder Cooling Tubes
3394   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3395   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3396   endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3397                                                                                         endladdercoolingtubeshape[i][0]->GetRmax(),
3398                                                                                         endladdercoolingtubeshape[i][0]->GetDz());
3399   TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3400   endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3401                                                                           endladdervirtualcoolingtubeshape[0],
3402                                                                           fSSDAir);
3403   endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3404                                                                           endladdervirtualcoolingtubeshape[1],
3405                                                                           fSSDAir);
3406   endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3407                                                                           endladdervirtualcoolingtubeshape[2],
3408                                                                           fSSDAir);
3409   endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3410                                                                           endladdervirtualcoolingtubeshape[3],
3411                                                                           fSSDAir);
3412   endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3413                                                                           endladdervirtualcoolingtubeshape[4],
3414                                                                           fSSDAir);
3415   TList* coolingtubelist = new TList();
3416   for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3417         virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3418         virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3419     coolingtubelist->Add(virtualcoolingtube[i]);
3420   }
3421         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3422         endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3423     coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3424         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3425         endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3426     coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3427         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3428         endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3429     coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3430         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3431         endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3432     coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3433         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3434         endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3435     coolingtubelist->Add(endladdervirtualcoolingtube[4]);
3436   return coolingtubelist;
3437 }
3438 ///////////////////////////////////////////////////////////////////////////////
3439 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3440   /////////////////////////////////////////////////////////////
3441   // Method generating SSD Cooling Block
3442   /////////////////////////////////////////////////////////////
3443   const Int_t kvertexnumber = 8;
3444   ///////////////////////////////////////
3445   // Vertex Positioning for TGeoXTru
3446   ///////////////////////////////////////
3447   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3448   vertexposition[0] = new TVector3(0.0,0.0);
3449   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3450   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3451                                           vertexposition[1]->Y());
3452   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3453                                           vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3454   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3455   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3456                                         + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3457   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3458                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3459                                         - fgkSSDCoolingBlockHoleLength[0]
3460                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3461                                           fgkSSDCoolingBlockHeight[0]
3462                                         - fgkSSDCoolingBlockHoleRadius[1],
3463                                           fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3464   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3465                                         - fgkSSDCoolingBlockHoleLength[0]),
3466                                           vertexposition[6]->Y());
3467   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3468                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3469   Double_t phi = 180.-alpha;
3470   Double_t psi = 180.+2.*alpha;
3471   Double_t deltapsi = psi/nedges;
3472   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3473   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3474                                                   fgkSSDCoolingBlockHoleCenter);
3475   for(Int_t i=0; i<nedges+1; i++){
3476         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3477                                                                                                radius*SinD(phi+i*deltapsi));
3478    *vertexposition[kvertexnumber+i] += (*transvector);
3479   }
3480   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3481   for(Int_t i=0; i<kvertexnumber; i++)
3482     vertexposition[kvertexnumber+nedges+1+i] =
3483                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3484   ///////////////////////////////////////////////////////////////////////
3485   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3486   ///////////////////////////////////////////////////////////////////////
3487   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3488   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3489   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3490   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3491         xvertexpoints[i] = vertexposition[i]->X();
3492         yvertexpoints[i] = vertexposition[i]->Y();
3493   }
3494   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3495                                                                                         yvertexpoints);
3496   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3497   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3498   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3499                                                                           ssdcoolingblockshape,
3500                                                                                   fSSDAlCoolBlockMedium);
3501   ssdcoolingblock->SetLineColor(fColorAl);
3502   /////////////////////////////////////////////////////////////
3503   // Deallocating memory
3504   /////////////////////////////////////////////////////////////
3505   delete [] vertexposition;
3506   delete xvertexpoints;
3507   delete yvertexpoints;
3508   /////////////////////////////////////////////////////////////
3509   return ssdcoolingblock;
3510 }
3511 /////////////////////////////////////////////////////////////////////////////////
3512 TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
3513   ///////////////////////////////////////////////////////
3514   const Int_t kssdchipcablesnumber    = 2;
3515   const Int_t kssdchipcableslaynumber = 2;
3516   const Int_t kvertexnumber                       = 4*(nedges+1)+4;
3517   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3518   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3519   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3520                                                  -  fgkSSDChipCablesHeight[0]
3521                                                  -  fgkSSDChipCablesHeight[1]);
3522   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3523   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3524   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3525                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3526                                                           - ssdchipcablesradius[0]
3527                                                           - fgkSSDChipCablesWidth[1]
3528                                                           - fgkSSDChipCablesWidth[2]);
3529   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3530                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3531                                                           +      fgkSSDChipCablesHeight[1]
3532                                                           +      fgkSSDSensorHeight);
3533   ///////////////////////////////////////////////////////
3534   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3535   ///////////////////////////////////////////////////////
3536   TVector3** vertexposition[kssdchipcableslaynumber];
3537   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3538                                                                                                   new TVector3*[4*(nedges+1)+4];
3539   Double_t ratio[4];
3540   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3541   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3542                    /  ssdchipcablesradius[0];
3543   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3544                    /  ssdchipcablesradius[0];
3545   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3546                    +  fgkSSDChipCablesHeight[1])
3547                    /  ssdchipcablesradius[0];
3548   Double_t phi = 180.;
3549   Double_t deltaphi = 180./nedges;
3550   Double_t angle = 0.0;
3551   Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3552   Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3553   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3554         xvertexpoints[i] = new Double_t[kvertexnumber];
3555         yvertexpoints[i] = new Double_t[kvertexnumber];
3556   }
3557   TVector3* vertex = new TVector3();
3558   TVector3* transvector[kssdchipcableslaynumber];
3559   transvector[0] = new TVector3(fgkSSDChipWidth,
3560                                                                 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3561   transvector[1] = new TVector3();
3562   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3563   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3564   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3565                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3566                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3567   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3568         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3569         transvector[1]->SetY(ssdchipcablesradius[0]
3570                                  +               fgkSSDChipCablesHeight[0]
3571                                  +               fgkSSDChipCablesHeight[1]);
3572         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3573                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3574                                                          - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3575                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3576                                                          - i*fgkSSDChipCablesHeight[0]);
3577                 vertexposition[i][2*(nedges+1)+2] =
3578                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3579                                 +                                fgkSSDChipCablesWidth[1]
3580                                 +                                fgkSSDChipCablesWidth[2],
3581                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3582                                 +                                fgkSSDChipCablesHeight[1]));
3583         vertexposition[i][2*(nedges+1)+3] =
3584                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3585                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3586                                 -                                fgkSSDChipCablesHeight[i]);
3587             for(Int_t j=0; j<nedges+1; j++){
3588                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3589                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3590                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3591                         vertexposition[0][(nedges+1)*i+j+2] =
3592                                                 new TVector3(*vertex+*transvector[i]);
3593                         vertexposition[1][(nedges+1)*i+j+2] =
3594                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3595                                                                          vertex->Y()*ratio[2*i]+transvector[i]->Y());
3596                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3597                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3598                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3599                                                 new TVector3(vertex->X()*ratio[2*i+1]
3600                                                         +                        transvector[i]->X(),
3601                                                                                  vertex->Y()*ratio[2*i+1]
3602                                                         +                transvector[i]->Y());
3603                 }
3604         }
3605         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3606                 for(Int_t j=0; j<kvertexnumber; j++){
3607                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3608                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3609                 }
3610                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3611                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3612                                                                                 xvertexpoints[i],yvertexpoints[i]);
3613                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3614                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3615                 ssdchipcable[kssdchipcablesnumber*k+i] =
3616                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3617                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3618                                                           (kssdchipcablesnumber*k+i)%2==0?
3619                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3620                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3621         }
3622         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3623                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3624   }
3625   /////////////////////////////////////////////////////////////
3626   // Mother Volume definition
3627   /////////////////////////////////////////////////////////////
3628   Double_t ssdchipseparation = fgkSSDSensorLength
3629                                                          - 2.*fgkSSDModuleStiffenerPosition[1]
3630                                                          - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3631                                                          - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3632   Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3633   Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3634                                                           +fgkSSDChipCablesWidth[1]
3635                                                           +fgkSSDChipCablesWidth[2]);
3636   Double_t dy = fgkSSDChipCablesLength[1];
3637   Double_t dz = SSDChipCablesHeigth;
3638   TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3639   TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3640                           ssdchipcablesmotherbox,fSSDAir);
3641   /////////////////////////////////////////////////////////////
3642   // Rotation and Translation Definition for positioning
3643   /////////////////////////////////////////////////////////////
3644   TGeoRotation* ssdchipcablesrot[5];
3645   ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3646   ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3647   ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3648   ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3649   ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3650   TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3651                                                                                                                 0.,0.,ssdchipcablesrot[2]);
3652   ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3653   ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3654   ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3655   ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3656   /////////////////////////////////////////////////////////////
3657   // Deallocating memory
3658   /////////////////////////////////////////////////////////////
3659   for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3660         delete [] xvertexpoints[i];
3661         delete [] yvertexpoints[i];
3662   }
3663   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3664   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3665   delete vertex;
3666   delete ssdchipcablesrot[0];
3667   delete ssdchipcablesrot[1];
3668   delete ssdchipcablesrot[3];
3669   /////////////////////////////////////////////////////////////
3670   return ssdchipcablesmother;
3671 }
3672 ///////////////////////////////////////////////////////////////////////////////
3673 TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3674   /////////////////////////////////////////////////////////////
3675   // SSD Chip Assembly
3676   /////////////////////////////////////////////////////////////
3677   TGeoVolume* ssdchipassembly = GetSSDChips();
3678   TList* ssdchipsystemlist = new TList();
3679   const Int_t knedges = 20;
3680   const Int_t kchipsystemnumber = 2;
3681   /////////////////////////////////////////////////////////////
3682   // Mother Volume containing SSDChipSystem
3683   /////////////////////////////////////////////////////////////
3684   TGeoXtru* chipsystemothershape[kchipsystemnumber];
3685   for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3686   const Int_t kmothervertexnumber = 12;
3687   Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3688   Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3689   Double_t ssdchipcablesradius[kchipsystemnumber];
3690   Double_t ssdchipseparation = fgkSSDSensorLength
3691                              - 2.*fgkSSDModuleStiffenerPosition[1]
3692                              - 2.*(fgkSSDStiffenerWidth
3693                              - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3694   for(Int_t i=0; i<kchipsystemnumber; i++)
3695         ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3696                                                    -  fgkSSDChipCablesHeight[0]
3697                                                    -  fgkSSDChipCablesHeight[1]);
3698   ///////////////////////
3699   // Setting the vertices
3700   ///////////////////////
3701   xmothervertex[0][0]  = -0.5*fgkSSDChipCablesLength[1];
3702   xmothervertex[0][1]  = xmothervertex[0][0];
3703   xmothervertex[0][2]  = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3704                                            + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3705   xmothervertex[0][3]  = xmothervertex[0][2];
3706   xmothervertex[0][4]  = 0.5*fgkSSDChipCablesLength[1];
3707   xmothervertex[0][5]  = xmothervertex[0][4];
3708   xmothervertex[0][6]  = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3709   xmothervertex[0][7]  = xmothervertex[0][6];
3710   xmothervertex[0][8]  = 0.0;
3711   xmothervertex[0][9]  = xmothervertex[0][8];
3712   xmothervertex[0][10] = xmothervertex[0][4];
3713   xmothervertex[0][11] = xmothervertex[0][10];
3714   for(Int_t i=0; i<kmothervertexnumber; i++)
3715         xmothervertex[1][i] = xmothervertex[0][i];
3716   for(Int_t i=0; i<kchipsystemnumber; i++){
3717         ymothervertex[i][0]  = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3718                                                  - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3719         ymothervertex[i][1]  = ssdchipseparation-ymothervertex[i][0];
3720         ymothervertex[i][2]  = ymothervertex[i][1];
3721         ymothervertex[i][3]  = ymothervertex[i][0];
3722         ymothervertex[i][4]  = ymothervertex[i][0];
3723         ymothervertex[i][5]  = 0.5*fgkSSDChipWidth;
3724         ymothervertex[i][6]  = ymothervertex[i][5];
3725         ymothervertex[i][7]  = ssdchipseparation-0.5*fgkSSDChipWidth;
3726         ymothervertex[i][8]  = ymothervertex[i][7];
3727         ymothervertex[i][9]  = ymothervertex[i][5];
3728         ymothervertex[i][10] = ymothervertex[i][5];
3729         ymothervertex[i][11] = ymothervertex[i][4];
3730   }
3731   //////////////////////////////////////////////////////////
3732   TGeoVolume* chipsystemother[kchipsystemnumber];
3733   const char* chipsytemothername[kchipsystemnumber] =
3734                                         {"SSDChipSytemother1","SSDChipSytemother2"};
3735   for(Int_t i=0; i<kchipsystemnumber; i++){
3736     chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3737                                                                         xmothervertex[i],ymothervertex[i]);
3738     chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3739                                                                                   -0.5*fgkSSDChipHeight);
3740     chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3741     chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3742                                                           chipsystemothershape[i],fSSDAir);
3743   }
3744   /////////////////////////////////////////////////////////////
3745   // SSD Chip Cables
3746   /////////////////////////////////////////////////////////////
3747   TGeoVolume* ssdchipcables[kchipsystemnumber];
3748   TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3749   TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3750   TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3751   //////////////////
3752   for(Int_t i=0; i<kchipsystemnumber; i++){
3753                 ssdchipcables[i] =
3754                 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3755                 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3756                 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3757                 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3758   }
3759   for(Int_t i=0; i<kchipsystemnumber; i++){
3760         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3761                 ssdchipcablestrans[i][j] = new TGeoTranslation();
3762                 ssdchipcablesrot[i][j] = new TGeoRotation();
3763                 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3764                 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3765                 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3766                                                   +                fgkSSDChipSeparationLength),
3767                                                                                         0.5*fgkSSDChipWidth,
3768                                                   -                                     0.5*fgkSSDChipHeight
3769                                                   -                                     fgkSSDChipCablesHeight[i+2]);
3770                 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3771                 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3772                 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3773
3774         }
3775         chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3776         ssdchipsystemlist->Add(chipsystemother[i]);
3777   }
3778   /////////////////////////////////////////////////////////////
3779   // Deallocating memory
3780   /////////////////////////////////////////////////////////////
3781   for(Int_t i=0; i<kchipsystemnumber; i++){
3782         for(Int_t j=0; j<fgkSSDChipNumber; j++){
3783                 delete ssdchipcablesrot[i][j];
3784                 delete ssdchipcablestrans[i][j];
3785         }
3786         delete ssdchipcablesrot[i];
3787         delete ssdchipcablestrans[i];
3788   }
3789   /////////////////////////////////////////////////////////////
3790   return ssdchipsystemlist;
3791 }
3792 ///////////////////////////////////////////////////////////////////////////////
3793 TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
3794   /////////////////////////////////////////////////////////////
3795   // SSD Chip Assembly Generation
3796   /////////////////////////////////////////////////////////////
3797   const Int_t kssdchiprownumber = 2;
3798   TGeoBBox* ssdchipcompshape[2];
3799   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3800                                                                                 0.5*fgkSSDChipLength,
3801                                                                                 0.5*fgkSSDChipWidth,
3802                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3803   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3804                                                                                 0.5*fgkSSDChipLength,
3805                                                                                 0.5*fgkSSDChipWidth,
3806                                                                                 0.5*fgkSSDChipGlueHeight);
3807   TGeoVolume* ssdchipcomp[2];
3808   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3809   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3810                                                                   fSSDChipGlueMedium);
3811   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3812   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3813   TGeoTranslation* ssdchipcomptrans[2];
3814   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3815   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3816   /////////////////////////////////////////////////////////////
3817   // Virtual Volume containing SSDChip
3818   /////////////////////////////////////////////////////////////
3819   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3820                                                                                                                  0.5*fgkSSDChipWidth,
3821                                                                                                                  0.5*fgkSSDChipHeight);
3822   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3823   /////////////////////////////////////////////////////////////
3824   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3825   Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3826                                                   fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3827                                    -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3828                                    -  0.5*fgkSSDChipWidth)};
3829   /////////////////////////////////////////////////////////////
3830   // Virtual Volume containing SSDChipAssembly
3831   /////////////////////////////////////////////////////////////
3832   TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3833   const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3834   Double_t xmothervertex[kssdmothervertexnumber];
3835   Double_t ymothervertex[kssdmothervertexnumber];
3836   ///////////////////////
3837   // Setting the vertices
3838   ///////////////////////
3839   xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3840   xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3841                                    - ymothervertex[0];
3842   xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3843   ymothervertex[2] = ymothervertex[1];
3844   xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3845   xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3846   ymothervertex[4] = ymothervertex[0];
3847   xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3848   xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3849                                    + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3850   ymothervertex[6] = ymothervertex[5];
3851   xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3852                                    - fgkSSDChipWidth;
3853   xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3854   ymothervertex[8] = ymothervertex[7];
3855   xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3856   ymothervertex[9] = ymothervertex[6];
3857   xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3858   xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3859   //////////////////////////////////////////////////////////
3860   ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3861                                                                         xmothervertex,ymothervertex);
3862   ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3863   ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3864   TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3865                                                           ssdchipmothershape,fSSDAir);
3866    /////////////////////////////////////////////////////////////
3867   for(Int_t i=0; i<kssdchiprownumber; i++)
3868     for(Int_t j=0; j<fgkSSDChipNumber; j++)
3869                 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3870                 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3871   return ssdchipmother;
3872 }
3873 /////////////////////////////////////////////////////////////////////////////////
3874 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3875   /////////////////////////////////////////////////////////////
3876   // Method returning a List containing pointers to Ladder Cable Volumes
3877   /////////////////////////////////////////////////////////////
3878   const Int_t kladdercablesegmentnumber = 2;
3879   /////////////////////////////////////////
3880   // LadderSegmentBBox Volume
3881   /////////////////////////////////////////
3882   TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3883   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3884                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3885   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3886                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3887                                                                            0.5*fgkSSDFlexWidth[0],
3888                                                                            0.5*fgkSSDLadderCableWidth,
3889                                                                            0.5*fgkSSDFlexHeight[i]);
3890   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3891                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3892   TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3893   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3894                         laddercablesegmentbbox[i] =
3895                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3896                                                                                  laddercablesegmentbboxshape[i],
3897                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3898             fSSDKaptonLadderCableMedium));
3899                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3900                                                                                                                    fColorPolyhamide);
3901   }
3902   TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3903   laddercablesegmentbboxtrans[0] =
3904                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3905                                                                                            0.5*fgkSSDFlexWidth[0],
3906                                                                                            0.5*fgkSSDLadderCableWidth,
3907                                                                                            0.5*fgkSSDFlexHeight[0]);
3908   laddercablesegmentbboxtrans[1] =
3909                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3910                                                                                            0.5*fgkSSDFlexWidth[0],
3911                                                                                            0.5*fgkSSDLadderCableWidth,
3912                                                                                            fgkSSDFlexHeight[0]
3913                                                                                            +0.5*fgkSSDFlexHeight[1]);
3914   TGeoVolume* laddercablesegmentbboxassembly =
3915                                                    new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3916   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3917                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3918                                                                                             laddercablesegmentbboxtrans[i]);
3919 /////////////////////////////////////////
3920 // LadderSegmentArb8 Volume
3921 /////////////////////////////////////////
3922   const Int_t kvertexnumber = 4;
3923   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3924   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3925                                                                                                   new TVector3*[kvertexnumber];
3926 //Shape Vertex Positioning
3927   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3928         laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3929         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3930                                                                                                                   i*fgkSSDFlexHeight[0]);
3931         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3932                                                                                    +                         fgkSSDFlexHeight[1]
3933                                                                                    +                      i*fgkSSDFlexHeight[0]);
3934         laddercablesegmentvertexposition[i][3] =
3935                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3936                                                                                 laddercablesegmentvertexposition[i][2]->Y());
3937   }
3938   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3939                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3940   char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3941                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3942   TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3943   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3944                                         GetArbShape(laddercablesegmentvertexposition[i],
3945                                                                 laddercablesegmentwidth[i],
3946                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3947                                                                 laddercablesegmentarbshapename[i]);
3948   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3949                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3950   TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3951   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3952                          laddercablesegmentarb[i] =
3953                                                    new TGeoVolume(laddercablesegmentarbname[i],
3954                                                                                   laddercablesegmentarbshape[i],
3955                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3956             fSSDKaptonLadderCableMedium));
3957                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3958                                                                                                                    fColorPolyhamide);
3959 }
3960   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3961   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3962                                                                                                  90.,90,-90.);
3963   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3964                                                                                                   0.,90.,0.);
3965   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3966                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3967                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3968                                                          + fgkSSDFlexWidth[0],0.,0.,
3969                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3970                                                      *(*laddercablesegmentarbrot[0])));
3971   TGeoVolume* laddercablesegmentarbassembly =
3972                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3973   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3974   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3975                                                                                    laddercablesegmentarbcombitrans);
3976 /////////////////////////////////////////
3977 // End Ladder Cable Volume
3978 /////////////////////////////////////////
3979   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3980   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3981                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3982   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3983                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3984                                                                            0.5*ssdendladdercablelength,
3985                                                                            0.5*fgkSSDLadderCableWidth,
3986                                                                            0.5*fgkSSDFlexHeight[i]);
3987   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3988                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3989   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3990   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3991                         ladderendcablesegmentbbox[i] =
3992                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3993                                                                                  ladderendcablesegmentbboxshape[i],
3994                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3995             fSSDKaptonLadderCableMedium));
3996                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3997                                                                                                                    fColorPolyhamide);
3998   }
3999   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4000   ladderendcablesegmentbboxtrans[0] =
4001                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4002                                                                                            0.5*ssdendladdercablelength,
4003                                                                                            0.5*fgkSSDLadderCableWidth,
4004                                                                                            0.5*fgkSSDFlexHeight[0]);
4005   ladderendcablesegmentbboxtrans[1] =
4006                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4007                                                                                            0.5*ssdendladdercablelength,
4008                                                                                            0.5*fgkSSDLadderCableWidth,
4009                                                                                            fgkSSDFlexHeight[0]
4010                                                                                            +0.5*fgkSSDFlexHeight[1]);
4011   TGeoVolume* ladderendcablesegmentbboxassembly =
4012                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4013   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4014                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4015                                                                                             ladderendcablesegmentbboxtrans[i]);
4016 /////////////////////////////////////////
4017   TList* laddercablesegmentlist = new TList();
4018   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4019   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4020   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4021   return laddercablesegmentlist;
4022   }
4023 /////////////////////////////////////////////////////////////////////////////////
4024 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
4025   /////////////////////////////////////////////////////////////
4026   // Method generating Ladder Cable Volumes Assemblies
4027   /////////////////////////////////////////////////////////////
4028   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4029   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4030   for(Int_t i=0; i<n; i++){
4031          TGeoTranslation* laddercabletrans = new TGeoTranslation(
4032                                                         i*(fgkCarbonFiberJunctionWidth),
4033                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4034                                                         i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4035     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4036         if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
4037   }
4038   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4039                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4040                                                                  fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4041                                           (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4042   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4043   return laddercable;
4044 }
4045 /////////////////////////////////////////////////////////////////////////////////
4046 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4047   /////////////////////////////////////////////////////////////
4048   // Method generating Ladder Cable Volumes Assembly
4049   /////////////////////////////////////////////////////////////
4050   TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4051   char laddercabletransname[30];
4052   for(Int_t i=0; i<n; i++){
4053         sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4054     laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4055         new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
4056   }
4057   return laddercableassembly;
4058 }
4059 /////////////////////////////////////////////////////////////////////////////////
4060 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4061   /////////////////////////////////////////////////////////////
4062   // Method generating Ladder Cable List Assemblies
4063   /////////////////////////////////////////////////////////////
4064   const Int_t kladdercableassemblynumber = 2;
4065   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4066   TGeoVolume* ladderCable[kladdercableassemblynumber];
4067   char laddercableassemblyname[30];
4068   TList* laddercableassemblylist = new TList();
4069   for(Int_t i=0; i<kladdercableassemblynumber; i++){
4070         sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4071         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4072         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4073                                          new TGeoCombiTrans((n-1)
4074                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4075                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4076                                                                                         0.,new TGeoRotation("",180,0.,0.)));
4077         laddercableassemblylist->Add(ladderCable[i]);
4078 }
4079   return laddercableassemblylist;
4080 }
4081 ///////////////////////////////////////////////////////////////////////////////
4082 void AliITSv11GeometrySSD::SetLadderSegment(){
4083   /////////////////////////////////////////////////////////////
4084   // Method Generating Ladder Segment Array
4085   /////////////////////////////////////////////////////////////
4086   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4087   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4088   if(!fCreateMaterials) CreateMaterials();
4089   if(!fTransformationMatrices) CreateTransformationMatrices();
4090   if(!fBasicObjects) CreateBasicObjects();
4091   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4092   // Placing Carbon Fiber Support
4093         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4094                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4095                                                                                         fcarbonfibersupportmatrix[j]);
4096                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4097                                                                                         fcarbonfibersupportmatrix[j]);
4098   }
4099   // Placing Carbon Fiber Junction
4100     for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4101         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4102                                                                    fcarbonfiberjunctionmatrix[j]);
4103   // Placing Carbon Fiber Lower Support
4104         for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4105                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4106                                                            fcarbonfiberlowersupportrans[j]);
4107   // Placing SSD Sensor Support
4108     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4109         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4110                                                                      fssdsensorsupport[1][i],
4111                                                            j+1,fssdsensorsupportmatrix[j]);
4112   // Placing SSD Cooling Tube Support
4113         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4114                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4115                                                                    fcoolingtubesupportmatrix[j]);
4116   // Placing SSD Cooling Tube
4117         for(Int_t j=0; j<2; j++)
4118                 for(Int_t k=0; k<2; k++){
4119                 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4120                 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4121                 }
4122   // Placing SSD Hybrid
4123     switch(i){
4124         case 0:
4125                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4126                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4127                 break;
4128     case 1:
4129                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4130                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4131                 break;
4132         }
4133         // Placing Cooling Block System
4134     fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4135         // Placing SSD Flex
4136         for(Int_t j=0; j<fgkflexnumber; j++){
4137       fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4138       fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4139         }
4140    }
4141 }
4142 ///////////////////////////////////////////////////////////////////////////////
4143 void AliITSv11GeometrySSD::SetEndLadderSegment(){
4144   /////////////////////////////////////////////////////////////
4145   // Method Generating End Ladder
4146   /////////////////////////////////////////////////////////////
4147   // End Ladder Carbon Fiber Junction
4148   /////////////////////////////////////////////////////////////
4149   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4150   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4151   if(!fCreateMaterials) CreateMaterials();
4152   if(!fTransformationMatrices) CreateTransformationMatrices();
4153   if(!fBasicObjects) CreateBasicObjects();
4154   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4155         for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4156                 fendladdersegment[i]->AddNode(j==2 ?
4157                                                         fendladdercarbonfiberjunction[i][1] :
4158                                                         fendladdercarbonfiberjunction[i][0],
4159                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4160   }
4161   /////////////////////////////////////////////////////////////
4162   // End Ladder Carbon Fiber Support
4163   /////////////////////////////////////////////////////////////
4164   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4165       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4166                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4167                   fendladdercarbonfibermatrix[i][j]);
4168           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4169                   fendladdercarbonfibermatrix[i][j]);
4170       }
4171   /////////////////////////////////////////////////////////////
4172   // End Ladder Mounting Block
4173   /////////////////////////////////////////////////////////////
4174   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4175        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4176                                                                          fendladdermountingblockcombitrans[i]);
4177   /////////////////////////////////////////////////////////////
4178   // End Ladder Mounting Block Clip
4179   /////////////////////////////////////////////////////////////
4180   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4181         for(Int_t j=0; j<2; j++)
4182                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,i+1,
4183                                                                          fendladdermountingblockclipmatrix[i][j]);
4184   /////////////////////////////////////////////////////////////
4185   // End Ladder Lower Supports
4186   /////////////////////////////////////////////////////////////
4187   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4188                                                                 fendladderlowersupptrans[0]);
4189   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4190                                                                 fendladderlowersupptrans[1]);
4191   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4192                                                                 fendladderlowersupptrans[2]);
4193   /////////////////////////////////////////////////////////////
4194   // End Ladder Cooling Tube Support
4195   /////////////////////////////////////////////////////////////
4196   for(Int_t i=0; i<2; i++)
4197         for(Int_t j=0; j<(i==0?4:2); j++)
4198                 fendladdersegment[i]->AddNode(fcoolingtubesupport,
4199                                                                           j+1,fendladdercoolingtubesupportmatrix[i][j]);
4200   /////////////////////////////////////////////////////////////
4201   // End Ladder Cooling Tube Support
4202   /////////////////////////////////////////////////////////////
4203   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4204   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4205   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4206   fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4207   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4208   fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4209   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4210   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4211   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4212   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
4213  // fendladdersegment[0]->CheckOverlaps(0.01);
4214  // fendladdersegment[1]->CheckOverlaps(0.01);
4215 }
4216 ///////////////////////////////////////////////////////////////////////////////
4217 void AliITSv11GeometrySSD::SetLadder(){
4218   /////////////////////////////////////////////////////////////
4219   // Method Generating Ladder of Layer 5 and 6
4220   /////////////////////////////////////////////////////////////
4221   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4222                                                                                                 fgkSSDLay6SensorsNumber};
4223   /////////////////////////////////////////////////////////////////////////////
4224   /// Generating Ladder Mother Volume Containing Ladder
4225   /////////////////////////////////////////////////////////////////////////////
4226   TGeoXtru* laddershape[fgkladdernumber];
4227   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4228   const Int_t kmothervertexnumber = 8;
4229   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4230   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4231   ///////////////////////
4232   // Setting the vertices
4233   ///////////////////////
4234   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4235                                                                 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4236   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4237   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
4238   xmothervertex[0][1] = xmothervertex[0][0];
4239   ymothervertex[0][1] = 0.0;
4240   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4241                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4242   ymothervertex[0][2] = ymothervertex[0][1];
4243   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4244   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4245   xmothervertex[0][4] = -xmothervertex[0][3];
4246   ymothervertex[0][4] = ymothervertex[0][3];
4247   xmothervertex[0][5] = -xmothervertex[0][2];
4248   ymothervertex[0][5] = ymothervertex[0][2];
4249   xmothervertex[0][6] = -xmothervertex[0][1];
4250   ymothervertex[0][6] = ymothervertex[0][1];
4251   xmothervertex[0][7] = -xmothervertex[0][0];
4252   ymothervertex[0][7] = ymothervertex[0][0];
4253   for(Int_t i=0; i<kmothervertexnumber; i++){
4254         xmothervertex[1][i] = xmothervertex[0][i];
4255         ymothervertex[1][i] = ymothervertex[0][i];
4256   }
4257   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4258   for(Int_t i=0; i<fgkladdernumber; i++){
4259         laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4260                                                                     ymothervertex[i]);
4261     laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4262     laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4263                                                                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4264     fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
4265         fladder[i]->SetLineColor(4);
4266  }
4267 ///////////////////////////////////////////////////////////////////////////
4268  if(!fCreateMaterials) CreateMaterials();
4269  if(!fTransformationMatrices) CreateTransformationMatrices();
4270  if(!fBasicObjects) CreateBasicObjects();
4271  SetLadderSegment();
4272  SetEndLadderSegment();
4273   for(Int_t i=0; i<fgkladdernumber; i++){
4274         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4275         //////////////////////////
4276         /// Placing Ladder Segment
4277         //////////////////////////
4278                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4279                                                                      fladdersegment[i==0 ? 1 : 0],
4280                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4281         //////////////////////////
4282         /// Placing SSD Sensor
4283         //////////////////////////
4284                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4285                                                         fssdsensormatrix[i][j]);
4286         }
4287         ///////////////////////////////
4288         /// Placing End Ladder Segment
4289         ///////////////////////////////
4290     fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4291         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4292    }
4293 /////////////////////////////////////////////////////////////////////////////
4294 /// Placing Ladder Cables
4295 /////////////////////////////////////////////////////////////////////////////
4296   Int_t sidecablenumber[2][2];
4297   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4298   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4299   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4300   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4301   Double_t carbonfibertomoduleposition[3];
4302   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4303   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4304                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4305          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4306          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4307          -            fgkSSDSensorCenterSupportThickness[0]);
4308   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4309                                                                  +   0.5*fgkCoolingTubeSupportHeight
4310          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4311   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4312   Double_t ssdendladdercablelength[4];
4313   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4314                                                          + fgkSSDSensorLength
4315                                                          - fgkSSDModuleStiffenerPosition[1]
4316                                                          - fgkSSDStiffenerWidth
4317                                                          - fgkSSDFlexWidth[0]
4318                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4319   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4320                                                          + fgkSSDModuleStiffenerPosition[1]
4321                                                          + fgkSSDStiffenerWidth
4322                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4323   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4324                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4325                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4326                                                          - kendladdercablecorrection;
4327   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4328                                                          + carbonfibertomoduleposition[1]
4329                                                          - fgkSSDModuleStiffenerPosition[1]
4330                                                          - fgkSSDStiffenerWidth)
4331                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4332   TList* laddercableassemblylist[4];
4333   const Int_t kendladdercablesnumber = 4;
4334   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4335         for(Int_t j=0; j<kendladdercablesnumber; j++){
4336                 laddercableassemblylist[j] =
4337                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4338                                                                    ssdendladdercablelength[j]);
4339             fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4340                                                                         j<2?1:2,fladdercablematrix[i][j]);
4341   }
4342 //  fladder[0]->CheckOverlaps(0.01);
4343 //  fladder[1]->CheckOverlaps(0.01);
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                                                                                   fSSDSupportRingAl);
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                                                                                   fSSDSupportRingAl);
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         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4599         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4600         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4601         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4602         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4603         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4604         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4605         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4606                                                                                 + fgkSSDMountingBlockHeight[2]
4607                                                                                 - fgkSSDMountingBlockHeight[0];
4608         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4609         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4610         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4611         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4612         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4613                                                                                                          mountingblockpiecedownyvertex[i]);
4614         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4615         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4616         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4617                                                                  mountingblockpiecedownshape[i],fSSDSupportRingAl);
4618         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4619     ///////////////////////////
4620     // Mounting Block Up Vertex
4621     ///////////////////////////
4622         mountingblockpieceupshape[i] = new TGeoXtru(2);
4623         sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4624         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4625         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4626                                                                                 + fgkMountingBlockSupportUpHeight[i];
4627         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4628         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4629                                                                                 + fgkSSDMountingBlockHeight[1]
4630                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4631                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4632         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4633         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4634         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4635         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4636         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4637         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4638         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4639         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4640                                                                                 + fgkSSDMountingBlockHeight[2]
4641                                                                                 - fgkSSDMountingBlockHeight[0];
4642         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4643         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4644         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4645         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4646         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4647                                                                                                          mountingblockpieceupyvertex[i]);
4648         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4649         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4650         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4651                                                                 mountingblockpieceupshape[i],fSSDSupportRingAl);
4652         mountingblockpieceup[i]->SetLineColor(fColorG10);
4653  }
4654   ///////////////////////////////////////////////////////////////////
4655   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4656   ///////////////////////////////////////////////////////////////////
4657   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4658   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4659   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4660   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4661   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4662   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4663   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4664   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4665   char mountingblocksupportrapezoidowname[40];
4666   char mountingblocksupportrapezoidupname[40];
4667   Double_t scalefactor = 3./4.;
4668   for(Int_t i=0; i<fgklayernumber; i++){
4669   ////////////////////////////////////////////
4670   // Mounting Block Support Down Trapezoid Vertex
4671   ////////////////////////////////////////////
4672         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4673         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4674                                                                                                  - mountingsupportedge[i];
4675         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4676         mountingblocksupportrapezoidownxvertex[i][1] =
4677                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4678         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4679                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4680                                                                                              - mountingblockpiecedownyvertex[i][0]);
4681         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4682         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4683         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4684         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4685         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4686         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4687         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4688                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4689         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4690                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4691         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4692         sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4693         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4694                                                                 mountingblocksupportrapezoidownshape[i],fSSDMountingBlockMedium);
4695         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4696   ////////////////////////////////////////////
4697   // Mounting Block Support Up Trapezoid Vertex
4698   ////////////////////////////////////////////
4699         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4700         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4701                                                                                                  - mountingsupportedge[i];
4702         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4703         mountingblocksupportrapezoidupxvertex[i][1] =
4704                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4705         mountingblocksupportrapezoidupyvertex[i][1] =
4706                                                                                                mountingblockpieceupyvertex[i][0]
4707                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4708                                                                                              - mountingblockpieceupyvertex[i][0]);
4709         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4710         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4711         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4712         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4713         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4714         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4715         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4716                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4717         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4718                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4719         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4720         sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4721         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4722                                                                 mountingblocksupportrapezoidupshape[i],fSSDMountingBlockMedium);
4723         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4724   }
4725   ///////////////////////////////////////////////////////////////////
4726   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4727   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4728   Double_t boxoriginup[fgklayernumber][2][3];
4729   Double_t boxorigindown[fgklayernumber][2][3];
4730   char mountingblocksupportboxdownname[34];
4731   char mountingblocksupportboxupname[34];
4732   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4733   mountingblocksupportrot->SetAngles(90.,180.,-90);
4734   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4735   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4736   TGeoHMatrix* laddersupportmatrix[2];
4737   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4738   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4739   /////////////////////////////////////////////////////////////
4740   // Creating Mother Volume for Containment
4741   /////////////////////////////////////////////////////////////
4742   Double_t *xmothervertex[fgklayernumber];
4743   Double_t *ymothervertex[fgklayernumber];
4744   for(Int_t i=0; i<fgklayernumber; i++){
4745         xmothervertex[i] = new Double_t[8];
4746         ymothervertex[i] = new Double_t[8];
4747   }
4748   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4749   TGeoVolume* downmotherladdersupport[fgklayernumber];
4750   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4751   TGeoVolume* upmotherladdersupport[fgklayernumber];
4752   char upmotheladdersupportname[30];
4753   char downmotheladdersupportname[30];
4754   for(Int_t i=0; i<fgklayernumber; i++){
4755         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4756                                                     -  mountingsupportedge[i];
4757         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4758         xmothervertex[i][1] = xmothervertex[i][0];
4759         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4760                                                         + fgkMountingBlockSupportWidth[0];
4761         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4762         ymothervertex[i][2] = ymothervertex[i][1];
4763         xmothervertex[i][3] = xmothervertex[i][2];
4764         ymothervertex[i][3] = -ymothervertex[i][0];
4765         xmothervertex[i][4] = -xmothervertex[i][0];
4766         ymothervertex[i][4] = ymothervertex[i][3];
4767         xmothervertex[i][5] = xmothervertex[i][4];
4768         ymothervertex[i][5] = -ymothervertex[i][1];
4769         xmothervertex[i][6] = -xmothervertex[i][2];
4770         ymothervertex[i][6] = ymothervertex[i][5];
4771         xmothervertex[i][7] = xmothervertex[i][6];
4772         ymothervertex[i][7] = ymothervertex[i][0];
4773         sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4774         sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4775     downmotherladdersupportshape[i] = new TGeoXtru(2);
4776         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4777         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4778     downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4779                                                                    +                       fgkMountingBlockSupportDownHeight
4780                                                                    +                       fgkSSDMountingBlockHeight[1]
4781                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4782                                                                    -                       fgkSSDModuleCoolingBlockToSensor);
4783     downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4784                                                                           downmotherladdersupportshape[i],fSSDAir);
4785     upmotherladdersupportshape[i] = new TGeoXtru(2);
4786         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4787         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4788     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4789                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4790                                                                    +                       fgkSSDMountingBlockHeight[1]
4791                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4792                                                                    -                       fgkSSDModuleCoolingBlockToSensor);
4793     upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4794                                                                                           upmotherladdersupportshape[i],fSSDAir);
4795   }
4796   for(Int_t i=0; i<fgklayernumber; i++){
4797         /////////////////////////
4798         // Setting the box origin
4799         /////////////////////////
4800         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4801         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4802                                                    +  0.5*fgkMountingBlockSupportDownHeight;
4803         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4804                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4805
4806         boxorigindown[i][1][0] = 0.0;
4807         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4808         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4809                                                    -      fgkMountingBlockSupportWidth[0]);
4810
4811         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4812         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4813                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4814         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4815                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4816
4817         boxoriginup[i][1][0] = 0.0;
4818         boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4819                                                  + 0.5*fgkMountingBlockSupportUpHeight[i];
4820         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4821                                                  - fgkMountingBlockSupportWidth[0]);
4822
4823         /////////////////////////
4824     // Setting the boxes
4825         /////////////////////////
4826         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4827                                                                                  +  fgkSSDMountingBlockLength[0]),
4828                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4829                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4830                                                                                         boxorigindown[i][0]);
4831     mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4832                                                                                         0.5*fgkMountingBlockSupportDownHeight,
4833                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4834                                                                                  -  fgkMountingBlockSupportWidth[0]),
4835                                                                                         boxorigindown[i][1]);
4836
4837         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4838                                                                                  +  fgkSSDMountingBlockLength[0]),
4839                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4840                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4841                                                                                         boxoriginup[i][0]);
4842
4843         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4844                                                                                         0.5*fgkMountingBlockSupportUpHeight[i],
4845                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4846                                                                      -  fgkMountingBlockSupportWidth[0]),
4847                                                                                         boxoriginup[i][1]);
4848         ///////////////////////////////////////
4849     // Adding the Volumes to Mother Volume
4850         ///////////////////////////////////////
4851         for(Int_t j=0; j<2; j++){
4852                 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4853                 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4854                 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4855                                                                                   mountingblocksupportboxdownshape[i][j],
4856                                                                                   fSSDMountingBlockMedium);
4857                 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4858                                                                                   mountingblocksupportboxupshape[i][j],
4859                                                                                   fSSDMountingBlockMedium);
4860                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4861                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4862                 for(Int_t k=0; k<2; k++){
4863                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4864                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4865                 }
4866         }
4867         for(Int_t k=0; k<2; k++){
4868                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4869                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4870                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4871                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4872             downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4873                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4874                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4875                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4876                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4877                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4878                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4879                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4880         }
4881   }
4882   TList* laddersupportlist = new TList();
4883   laddersupportlist->Add(downmotherladdersupport[0]);
4884   laddersupportlist->Add(upmotherladdersupport[0]);
4885   laddersupportlist->Add(downmotherladdersupport[1]);
4886   laddersupportlist->Add(upmotherladdersupport[1]);
4887   /////////////////////////////////////////////////////////////
4888   // Deallocating memory
4889   /////////////////////////////////////////////////////////////
4890   for(Int_t i=0; i<fgklayernumber; i++){
4891         for(Int_t j=0; j<nedges+1; j++)
4892                 delete vertex[i][j];
4893         delete mountingsupportedgevector[i];
4894         delete [] vertex[i];
4895         delete vertexlist[i];
4896         delete [] xsidevertex[i];
4897         delete [] ysidevertex[i];
4898         delete [] xcentervertex[i];
4899         delete [] ycentervertex[i];
4900         delete [] xsidelowervertex[i];
4901         delete [] ysidelowervertex[i];
4902         delete [] xcenterlowervertex[i];
4903         delete [] ycenterlowervertex[i];
4904   }
4905   delete xsidevertex;
4906   delete ysidevertex;
4907   delete xcentervertex;
4908   delete ycentervertex;
4909   delete xsidelowervertex;
4910   delete ysidelowervertex;
4911   delete xcenterlowervertex;
4912   delete ycenterlowervertex;
4913   delete globalrefladdersupportrot;
4914   delete mountingblocksupportrot;
4915   /////////////////////
4916   return laddersupportlist;
4917 }
4918  ////////////////////////////////////////////////////////////////////////////////
4919 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4920 //////////////////////////////////////////
4921 // Method Generating Ladder Support Ring
4922 //////////////////////////////////////////
4923   if(!fCreateMaterials) CreateMaterials();
4924   if(!fTransformationMatrices) CreateTransformationMatrices();
4925   if(!fBasicObjects) CreateBasicObjects();
4926   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4927   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4928     const Int_t kssdlayladdernumber[fgklayernumber] =
4929                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4930   Double_t mountingsupportedge[fgklayernumber];
4931   Double_t mountingblockratio[fgklayernumber];
4932   Double_t theta[fgklayernumber];
4933   Double_t phi[fgklayernumber];
4934   for(Int_t i=0; i<fgklayernumber; i++){
4935         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4936     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4937                                                           *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4938                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4939                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4940                                                           / kssdlayladdernumber[i])));
4941     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4942                          / fgkMountingBlockSupportRadius[i]);
4943     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4944   }
4945   TGeoRotation* globalrot = new TGeoRotation();
4946   globalrot->SetAngles(0.,-90.,0.);
4947   TGeoRotation** laddersupportrot[fgklayernumber];
4948   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4949   for(Int_t i=0; i<fgklayernumber; i++){
4950         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4951         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4952         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4953                 laddersupportrot[i][j] = new TGeoRotation();
4954                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4955                 switch(i){
4956                         case 0: //Ladder of Layer5
4957                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4958                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4959                                                                             laddersupportmatrix[i][j]);
4960                         break;
4961                         case 1: //Ladder of Layer6
4962                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4963                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4964                                                                               laddersupportmatrix[i][j]);
4965                         break;
4966                 }
4967     }
4968   }
4969   /////////////////////////////////////////////////////////////
4970   // Creating Lower Ladder Support
4971   /////////////////////////////////////////////////////////////
4972   TVector3** ringsupportvertex[fgklayernumber];
4973   Double_t angle = 360./nedges;
4974   for(Int_t i=0; i<fgklayernumber; i++){
4975     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4976         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4977                                                         *                          TMath::Cos(theta[i]));
4978         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4979                                                         -                          mountingsupportedge[i],
4980                                                                                    ringsupportvertex[i][0]->Y());
4981         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4982                                                                                    ringsupportvertex[i][1]->Y());
4983     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4984         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4985            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4986            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4987            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4988            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4989         }
4990         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4991     for(Int_t j=0; j<nedges+1; j++){
4992                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4993                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
4994                                                  (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
4995         }
4996   }
4997   Double_t **xmothervertex = new Double_t*[fgklayernumber];
4998   Double_t **ymothervertex = new Double_t*[fgklayernumber];
4999   for(Int_t i=0; i<fgklayernumber; i++){
5000         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5001         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5002         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5003                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5004                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5005         }
5006   }
5007   char lowerladdersupportname[30];
5008   TGeoXtru* lowerladdersupportshape[fgklayernumber];
5009   TGeoVolume* lowerladdersupport[fgklayernumber];
5010   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5011   lowerladdersupportrot->SetAngles(90.,180.,-90);
5012   for(Int_t i=0; i<fgklayernumber; i++){
5013         lowerladdersupportshape[i] = new TGeoXtru(2);
5014         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5015                                                                                           xmothervertex[i],ymothervertex[i]);
5016         lowerladdersupportshape[i]->DefineSection(0,0.);
5017     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5018         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5019     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5020                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
5021         lowerladdersupport[i]->SetLineColor(fColorAl);
5022         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5023         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5024   }
5025   /////////////////////////////////////////////////////////////
5026   // Deallocating memory
5027   /////////////////////////////////////////////////////////////
5028   for(Int_t i=0; i<fgklayernumber; i++){
5029         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5030                 delete ringsupportvertex[i][j];
5031         delete [] ringsupportvertex[i];
5032   }
5033   for(Int_t i=0; i<fgklayernumber; i++){
5034         delete [] xmothervertex[i];
5035         delete [] ymothervertex[i];
5036   }
5037   delete xmothervertex;
5038   delete ymothervertex;
5039   delete globalrot;
5040   for(Int_t i=0; i<fgklayernumber; i++){
5041         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5042                 delete laddersupportrot[i][j];
5043         delete [] laddersupportrot[i];
5044   }
5045  }
5046  ////////////////////////////////////////////////////////////////////////////////
5047  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5048   /////////////////////////////////////////////////////////////
5049   // Method generating Endcap CoverPlate
5050   /////////////////////////////////////////////////////////////
5051   // Holes Definition
5052   ///////////////////
5053   Int_t nendcapcoverplateholedges = 30;
5054   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5055   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5056                                                           0.5*fgkEndCapCoverPlateThickness};
5057   TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5058                                                                                                               nendcapcoverplateholedges,holesection);
5059   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5060                                                                                   endcapcoverplatesmallholeshape,fSSDAir);
5061   endcapcoverplatesmallhole->SetLineColor(6);
5062   TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5063                                                                                                               nendcapcoverplateholedges,holesection);
5064   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5065                                                                                   endcapcoverplatebigholeshape,fSSDAir);
5066   endcapcoverplatebighole->SetLineColor(6);
5067   //////////////////////////
5068   // Screw Piece Definition
5069   //////////////////////////
5070   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5071   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5072                                                                                                       CosD(0.5*smallscrewangle),
5073                                                                                                       0.5*fgkEndCapCoverPlateThickness);
5074   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5075                                                                                                 endcapsmallscrewpieceshape,
5076                                                                                                 fSSDCoolingTubePhynox);
5077   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5078   ///////////////////
5079   // Box Definition
5080   ///////////////////
5081   TGeoBBox* endcapcoverplateboxshape[4];
5082   TGeoVolume* endcapcoverplatebox[4];
5083   Double_t boxorigin[5][3];
5084   boxorigin[0][0] = 0.;
5085   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5086   boxorigin[0][2] = 0.;
5087
5088   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5089   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5090   boxorigin[1][2] = 0.;
5091
5092   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5093                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
5094   boxorigin[2][1] = boxorigin[1][1];
5095   boxorigin[2][2] = 0.;
5096
5097   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5098                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5099   boxorigin[3][1] = boxorigin[1][1];
5100   boxorigin[3][2] = 0.;
5101
5102   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5103                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5104                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
5105                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5106
5107   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5108                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5109                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5110                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5111                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5112
5113   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5114                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5115                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5116                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5117                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5118
5119   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5120                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
5121                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5122                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
5123                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5124
5125   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5126                                                                            fSSDAir);
5127   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5128                                                                            fSSDAir);
5129   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5130                                                                            fSSDAir);
5131   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5132                                                                            fSSDAir);
5133   endcapcoverplatebox[0]->SetLineColor(6);
5134   endcapcoverplatebox[1]->SetLineColor(6);
5135   endcapcoverplatebox[2]->SetLineColor(6);
5136   endcapcoverplatebox[3]->SetLineColor(6);
5137   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5138   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5139                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
5140                                                                                         0.5*fgkEndCapCoverPlateThickness,
5141                                                                                         endcapfillingboxorigin);
5142   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5143                                                                            fSSDAir);
5144   endcapfillingbox->SetLineColor(6);
5145   ////////////////////////////
5146   // Contour Xtru Definition
5147   ////////////////////////////
5148   const Int_t kcontourvertexnumber = 10;
5149   Double_t xcontourvertex[kcontourvertexnumber];
5150   Double_t ycontourvertex[kcontourvertexnumber];
5151   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5152   xcontourvertex[1] = xcontourvertex[0];
5153   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5154   xcontourvertex[3] = xcontourvertex[2];
5155   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5156   xcontourvertex[5] = xcontourvertex[4];
5157   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5158   xcontourvertex[7] = xcontourvertex[6];
5159   xcontourvertex[8] = xcontourvertex[4];
5160   xcontourvertex[9] = xcontourvertex[8];
5161   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5162                                         - (kendcapcoverplatesmallholenumber[1]-1)
5163                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5164   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5165                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5166   ycontourvertex[2] = ycontourvertex[1];
5167   ycontourvertex[3] = ycontourvertex[0];
5168   ycontourvertex[4] = ycontourvertex[3];
5169   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5170   ycontourvertex[6] = ycontourvertex[5];
5171   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5172                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5173                                         + fgkEndCapCoverPlateSmallHoleRadius;
5174   ycontourvertex[8] = ycontourvertex[7];
5175   ycontourvertex[9] = ycontourvertex[0];
5176   TGeoXtru* contourshape = new TGeoXtru(2);
5177   contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5178   contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5179   contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5180   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,fSSDAir);
5181   contour->SetLineColor(6);
5182   /////////////////////////////
5183   // Hole Contour Xtru Definition
5184   ////////////////////////////
5185   const Int_t kholecontourvertexnumber = 10;
5186   Double_t xholecontourvertex[2][kcontourvertexnumber];
5187   Double_t yholecontourvertex[2][kcontourvertexnumber];
5188   xholecontourvertex[0][0] = xcontourvertex[0];
5189   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5190   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5191   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5192   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5193                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5194                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5195   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5196   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5197                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5198   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5199   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5200   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5201
5202   yholecontourvertex[0][0] = ycontourvertex[1];
5203   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5204   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5205   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5206   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5207   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5208                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5209   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5210   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5211   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5212   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5213
5214   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5215   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5216   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5217   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5218   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5219                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5220                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5221   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5222   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5223                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5224   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5225   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5226   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5227
5228   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5229                                                    - fgkEndCapCoverPlateWidth[0]);
5230   yholecontourvertex[1][1] = ycontourvertex[0];
5231   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5232   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5233   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5234   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5235                                                    - fgkEndCapCoverPlateWidth[0]
5236                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5237   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5238   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5239   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5240   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5241
5242   TGeoXtru* holecontourshape[2];
5243   holecontourshape[0] = new TGeoXtru(2);
5244   holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5245                                                                   yholecontourvertex[0]);
5246   holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5247   holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5248
5249   holecontourshape[1] = new TGeoXtru(2);
5250   holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5251                                                                   yholecontourvertex[1]);
5252   holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5253   holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5254
5255   TGeoVolume* holecontour[2];
5256   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],fSSDAir);
5257   holecontour[0]->SetLineColor(6);
5258   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],fSSDAir);
5259   holecontour[1]->SetLineColor(6);
5260   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5261                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5262   TGeoTranslation*  bigholetrans[3];
5263   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5264                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5265   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5266                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5267                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5268   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5269                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5270   /////////////////////////////////
5271   // Mother Volume Xtru Definition
5272   /////////////////////////////////
5273   const Int_t kmothervertexnumber = 12;
5274   Double_t xmothervertex[kmothervertexnumber];
5275   Double_t ymothervertex[kmothervertexnumber];
5276   xmothervertex[0]  = xcontourvertex[0];
5277   xmothervertex[1]  = xmothervertex[0];
5278   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5279   xmothervertex[3]  = xmothervertex[2];
5280   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5281   xmothervertex[5]  = xmothervertex[4];
5282   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5283   xmothervertex[7]  = xmothervertex[6];
5284   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5285                                         + fgkEndCapCoverPlateLength[2];
5286   xmothervertex[9]  = xmothervertex[8];
5287   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5288   xmothervertex[11] = xmothervertex[10];
5289
5290   ymothervertex[0]  = ycontourvertex[0];
5291   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5292   ymothervertex[2]  = ymothervertex[1];
5293   ymothervertex[3]  = ycontourvertex[1];
5294   ymothervertex[4]  = ymothervertex[3];
5295   ymothervertex[5]  = ymothervertex[1];
5296   ymothervertex[6]  = ymothervertex[5];
5297   ymothervertex[7]  = ymothervertex[0];
5298   ymothervertex[8]  = ymothervertex[7];
5299   ymothervertex[9]  = ymothervertex[8]
5300                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5301   ymothervertex[10] = ymothervertex[9];
5302   ymothervertex[11] = ymothervertex[8];
5303   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5304   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5305   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5306   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5307   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5308   ////////////////////////////////////////
5309   // Adding Nodes
5310   ////////////////////////////////////////
5311 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5312   TGeoTranslation*** endcapcoverplatesmallholetrans;
5313   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5314   Double_t transx[4] = {0,
5315                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5316                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5317                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5318                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5319                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5320   Int_t index = 0;
5321   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5322         endcapcoverplatesmallholetrans[i] =
5323                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5324     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5325                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5326             endcapcoverplatesmallholetrans[i][j] =
5327                 new TGeoTranslation(transx[i],
5328                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5329             if(index!=10){
5330                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5331                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5332                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5333                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5334                 }
5335                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5336                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5337                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5338     }
5339   }
5340   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5341   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5342   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5343   mothercoverplate->AddNode(endcapfillingbox,1);
5344   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5345   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5346   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5347   mothercoverplate->AddNode(holecontour[0],1);
5348   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5349   mothercoverplate->AddNode(holecontour[1],1);
5350   mothercoverplate->AddNode(contour,1);
5351   /////////////////////////////////
5352   return mothercoverplate;
5353  }
5354  ////////////////////////////////////////////////////////////////////////////////
5355  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5356   /////////////////////////////////////////////////////////////
5357   // Getting EndCap Cooling Tube
5358   /////////////////////////////////////////////////////////////
5359   TGeoTorus* endcapcoolingtubetorushape[5];
5360   TGeoVolume* endcapcoolingtubetorus[5];
5361   TGeoTube* endcapcoolingtubeshape[4];
5362   TGeoVolume* endcapcoolingtube[4];
5363   char endcapcoolingtubetorusname[30];
5364   char endcapcoolingtubename[30];
5365   TGeoTorus* endcapcoolingwatertubetorushape[5];
5366   TGeoVolume* endcapcoolingwatertubetorus[5];
5367   TGeoTube* endcapcoolingwatertubeshape[4];
5368   TGeoVolume* endcapcoolingwatertube[4];
5369   char endcapcoolingwatertubetorusname[30];
5370   char endcapcoolingwatertubename[30];
5371   for(Int_t i=0; i<5; i++){
5372         sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5373         sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5374         sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5375         sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5376         if(i==3){
5377                 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5378                                                                                 fgkEndCapCoolingTubeRadiusMin,
5379                                                                                 fgkEndCapCoolingTubeRadiusMax,
5380                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5381                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5382                                                                                 0.,fgkEndCapCoolingTubeRadiusMin,
5383                                                                                 90.0,fgkEndCapCoolingTubeAngle[3]);
5384     }
5385         else{
5386                 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5387                                                                           :fgkEndCapCoolingTubeAxialRadius[1],
5388                                                                            fgkEndCapCoolingTubeRadiusMin,
5389                                                                            fgkEndCapCoolingTubeRadiusMax,
5390                                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5391                 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5392                                                                                :fgkEndCapCoolingTubeAxialRadius[1],
5393                                                                                  0.,fgkEndCapCoolingTubeRadiusMin,
5394                                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5395         }
5396         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5397                                                                                            endcapcoolingtubetorushape[i],
5398                                                                                            fSSDCoolingTubePhynox);
5399         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5400                                                                                                         endcapcoolingwatertubetorushape[i],
5401                                                                                                         fSSDCoolingTubeWater);
5402     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5403     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5404     if(i<4){
5405                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5406                                                                   fgkEndCapCoolingTubeRadiusMax,
5407                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5408                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5409                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5410         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5411                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5412         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5413                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5414                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5415                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5416         }
5417   }
5418   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5419   /////////////////////////////////////////
5420   // Transformation for Volume Positioning
5421   /////////////////////////////////////////
5422   TGeoCombiTrans* coolingtubecombitrans[6];
5423   TGeoRotation* coolingtuberot[8];
5424   TGeoTranslation* coolingtubetrans[6];
5425   TGeoHMatrix* coolingtubematrix[4];
5426   TGeoCombiTrans* torustubecombitrans[4];
5427   TGeoRotation* torustuberot[7];
5428   TGeoTranslation* torustubetrans[4];
5429   TGeoHMatrix* torustubematrix[5];
5430   TGeoCombiTrans* coolingwatertubecombitrans[6];
5431   TGeoRotation* coolingwatertuberot[8];
5432   TGeoTranslation* coolingwatertubetrans[6];
5433   TGeoHMatrix* coolingwatertubematrix[4];
5434   TGeoCombiTrans* toruswatertubecombitrans[4];
5435   TGeoRotation* toruswatertuberot[7];
5436   TGeoTranslation* toruswatertubetrans[4];
5437   TGeoHMatrix* toruswatertubematrix[5];
5438   for(Int_t i=0; i<8; i++){
5439     if(i<6){
5440          coolingtubetrans[i] = new TGeoTranslation();
5441          coolingwatertubetrans[i] = new TGeoTranslation();
5442     }
5443     if(i<8){
5444          coolingtuberot[i] = new TGeoRotation();
5445          coolingwatertuberot[i] = new TGeoRotation();
5446     }
5447     if(i<4){
5448          torustubetrans[i] = new TGeoTranslation();
5449          toruswatertubetrans[i] = new TGeoTranslation();
5450     }
5451     if(i<7){
5452          torustuberot[i] = new TGeoRotation();
5453          toruswatertuberot[i] = new TGeoRotation();
5454         }
5455   }
5456   /////////////////////////////////////////
5457   // Transformation for Inox Volume Positioning
5458   /////////////////////////////////////////
5459   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5460                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5461   coolingtuberot[0]->SetAngles(0.,90.,0.);
5462   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5463                                                                                                 *coolingtuberot[0]);
5464
5465   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5466   coolingtuberot[1]->SetAngles(0.,90.,0.);
5467   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5468                                                                                                 *coolingtuberot[1]);
5469
5470   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5471                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5472                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5473                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5474                                                                           0.);
5475   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5476   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5477                                                                                                 *coolingtuberot[2]);
5478
5479   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5480                                            *                             (*coolingtubecombitrans[1]));
5481
5482   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5483                                                                          endcapcoolingtubeshape[1]->GetDz());
5484   torustuberot[0]->SetAngles(0.,90.,0.);
5485   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5486
5487   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5488
5489   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5490                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5491   coolingtuberot[3]->SetAngles(0.,90.,0.);
5492   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5493                                                                                                 *coolingtuberot[3]);
5494   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5495   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5496   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5497
5498   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5499                                                                         endcapcoolingtubeshape[2]->GetDz());
5500   torustuberot[1]->SetAngles(0.,90.,0.);
5501   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5502   torustuberot[2]->SetAngles(180.,0.,0.);
5503   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5504   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5505
5506   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5507                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5508   torustuberot[3]->SetAngles(0.,90.,0.);
5509   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5510   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5511   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5512   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5513
5514   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5515                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5516   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5517   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5518                                                                                                 *coolingtuberot[5]);
5519   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5520   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5521   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5522
5523   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5524                                                                         endcapcoolingtubeshape[0]->GetDz());
5525   torustuberot[5]->SetAngles(0.,90.,0.);
5526   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5527   torustuberot[6]->SetAngles(-90.,0.,0.);
5528   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5529   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5530
5531   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5532                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5533   coolingtuberot[6]->SetAngles(0.,90.,0.);
5534   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5535                                                                                                 *coolingtuberot[6]);
5536   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5537   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5538   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5539     /////////////////////////////////////////
5540   // Transformation for Water Volume Positioning
5541   /////////////////////////////////////////
5542   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5543                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5544   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5545   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5546                                                                                                      *coolingwatertuberot[0]);
5547
5548   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5549   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5550   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5551                                                                                                      *coolingwatertuberot[1]);
5552
5553   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5554                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5555                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5556                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5557                                                                               0.);
5558   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5559   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5560                                                                                                     *coolingwatertuberot[2]);
5561
5562   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5563                                            *                                 (*coolingwatertubecombitrans[1]));
5564
5565   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5566                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5567   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5568   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5569                                                                                                    *toruswatertuberot[0]);
5570
5571   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5572                                                   *                                     (*toruswatertubecombitrans[0]));
5573
5574   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5575                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5576   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5577   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5578                                                                                                      *coolingwatertuberot[3]);
5579   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5580   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5581                                                         *                                 (*coolingwatertubecombitrans[3]));
5582   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5583
5584   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5585                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5586   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5587   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5588                                                                                                    *toruswatertuberot[1]);
5589   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5590   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5591                                                   *                 (*toruswatertubecombitrans[1]));
5592   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5593
5594   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5595                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5596   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5597   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5598                                                                                                    *toruswatertuberot[3]);
5599   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5600   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5601                                                   *                                     (*toruswatertubecombitrans[2]));
5602   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5603
5604   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5605                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5606   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5607   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5608                                                                                                      *coolingwatertuberot[5]);
5609   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5610   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5611                                                         *                                 (*coolingwatertubecombitrans[4]));
5612   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5613
5614   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5615                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5616   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5617   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5618                                                                                                    *toruswatertuberot[5]);
5619   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5620   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5621                                                   *                 (*toruswatertubecombitrans[3]));
5622   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5623
5624   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5625                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5626   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5627   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5628                                                                                                      *coolingwatertuberot[6]);
5629   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5630   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5631                                                         *                                 (*coolingwatertubecombitrans[5]));
5632   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5633   /////////////////////////////////////////
5634   // Positioning Volumes
5635   /////////////////////////////////////////
5636   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5637   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5638
5639   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5640   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5641
5642   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5643   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5644
5645   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5646   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5647
5648   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5649   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5650
5651   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5652   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5653
5654   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5655   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5656
5657   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5658   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5659
5660   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5661   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5662
5663   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5664   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5665   /////////////////////////////////////////////////////////////
5666   // Deallocating memory
5667   /////////////////////////////////////////////////////////////
5668   for(Int_t i=0; i<8; i++){
5669     if(i<6){
5670          delete coolingtubetrans[i];
5671          delete coolingwatertubetrans[i];
5672          if(i!=0){
5673           delete coolingtubecombitrans[i];
5674           delete coolingwatertubecombitrans[i];
5675          }
5676         }
5677     if(i<8){
5678           delete coolingtuberot[i];
5679           delete coolingwatertuberot[i];
5680     }
5681     if(i<4){
5682                 delete torustubetrans[i];
5683                 delete toruswatertubetrans[i];
5684                 delete torustubecombitrans[i];
5685                 delete toruswatertubecombitrans[i];
5686         }
5687     if(i<7){
5688          delete torustuberot[i];
5689          delete toruswatertuberot[i];
5690         }
5691   }
5692   /////////////////////////////////////////////////////////////
5693   return endcapcoolingtubemother;
5694  }
5695  ////////////////////////////////////////////////////////////////////////////////
5696  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5697   /////////////////////////////////////////////////////////////
5698   // Getting EndCap Cover Side
5699   /////////////////////////////////////////////////////////////
5700   const Int_t kendcapcoverholenumber[2] = {7,5};
5701   const Int_t kvertexnumber = 15;
5702   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5703   xvertex[0]  = 0.0;
5704   xvertex[1]  = xvertex[0];
5705   xvertex[2]  = fgkEndCapSideCoverLength[0];
5706   xvertex[3]  = fgkEndCapSideCoverLength[1];
5707   xvertex[4]  = xvertex[3];
5708   xvertex[5]  = fgkEndCapSideCoverLength[2];
5709   xvertex[6]  = xvertex[5];
5710   xvertex[7]  = xvertex[2];
5711   xvertex[8]  = xvertex[7];
5712   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5713   xvertex[10] = xvertex[9];
5714   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5715                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5716                           * fgkEndCapSideCoverLength[4];
5717   xvertex[12] = xvertex[11];
5718   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5719                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5720                           * fgkEndCapSideCoverLength[4];
5721   xvertex[14] = xvertex[13];
5722   yvertex[0]  = 0.0;
5723   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5724   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5725   yvertex[3]  = yvertex[2];
5726   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5727   yvertex[5]  = yvertex[4];
5728   yvertex[6]  = yvertex[0];
5729   yvertex[7]  = yvertex[6];
5730   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5731   yvertex[9]  = yvertex[8];
5732   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5733   yvertex[11] = yvertex[10];
5734   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5735   yvertex[13] = yvertex[12];
5736   yvertex[14] = yvertex[6];
5737   TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5738   endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5739   endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5740   endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5741   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5742                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5743   endcapsidecover->SetLineColor(fColorPhynox);
5744   ////////////////////////////////////////////
5745   // Defininition of Mother Volume
5746   ////////////////////////////////////////////
5747   const Int_t kmothervertexnumber = 7;
5748   Double_t xmothervertex[kmothervertexnumber];
5749   Double_t ymothervertex[kmothervertexnumber];
5750   for(Int_t i=0; i<kmothervertexnumber; i++){
5751         xmothervertex[i] = xvertex[i];
5752         ymothervertex[i] = yvertex[i];
5753   }
5754   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5755   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5756   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5757   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5758   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5759                                                                 endcapsidecovermothershape,fSSDAir);
5760   ////////////////////////////////////////////
5761   endcapsidecovermother->AddNode(endcapsidecover,1);
5762   TGeoBBox* endcapsidecoverboxshape[4];
5763   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5764                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5765                                                                0.5*fgkEndCapSideCoverLength[4],
5766                                                                    0.5*fgkEndCapSideCoverThickness);
5767   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5768                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5769                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5770                                                          -     fgkEndCapSideCoverLength[4]),
5771                                                                    0.5*fgkEndCapSideCoverThickness);
5772   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5773                                                                0.5*fgkEndCapSideCoverLength[4],
5774                                                                    0.5*fgkEndCapSideCoverThickness);
5775   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5776                                                                0.5*fgkEndCapSideCoverWidth[5],
5777                                                                    0.5*fgkEndCapSideCoverThickness);
5778   TGeoVolume* endcapsidecoverbox[4];
5779   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5780   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5781   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5782   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5783   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5784 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5785   TGeoTranslation** endcapsidecoverboxtrans;
5786   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5787   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5788                                                          +                                         fgkEndCapSideCoverLength[0],
5789                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5790                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5791   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5792                                                          +                     xvertex[11],
5793                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5794                                                          +                     yvertex[12],0.);
5795   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5796                                                          +                     xvertex[11],
5797                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5798                                                          +                     yvertex[12]
5799                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5800                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5801   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5802   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5803   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5804   for(Int_t i=0; i<2; i++)
5805         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5806                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5807                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5808                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5809                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5810                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5811                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5812                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5813         }
5814   for(Int_t i=0; i<2; i++)
5815         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5816                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5817                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5818                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5819                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5820                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5821                                                         +fgkEndCapSideCoverLength[4]),0.0);
5822                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5823                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5824                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5825                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5826         }
5827         return endcapsidecovermother;
5828  }
5829  ////////////////////////////////////////////////////////////////////////////////
5830  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5831  ////////////////////////////////////////////////////////////////////////////////
5832  // Method returning Interface Card A, Interface Card B, Supply Card
5833  ////////////////////////////////////////////////////////////////////////////////
5834  /////////////////////
5835  // Supply Card
5836  /////////////////////
5837  // Electronic Board Back Al Plane
5838  const Int_t kelectboardbackvertexnumber = 8;
5839  Double_t xelectboardback[kelectboardbackvertexnumber];
5840  Double_t yelectboardback[kelectboardbackvertexnumber];
5841  xelectboardback[0] = 0.0;
5842  xelectboardback[1] = xelectboardback[0];
5843  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5844  xelectboardback[3] = xelectboardback[2];
5845  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5846  xelectboardback[5] = xelectboardback[4];
5847  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5848  xelectboardback[7] = xelectboardback[6];
5849
5850  yelectboardback[0] = 0.0;
5851  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5852  yelectboardback[2] = yelectboardback[1];
5853  yelectboardback[3] = yelectboardback[0];
5854  yelectboardback[4] = yelectboardback[3];
5855  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5856  yelectboardback[6] = yelectboardback[5];
5857  yelectboardback[7] = yelectboardback[4];
5858  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5859  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5860                                                                         xelectboardback,yelectboardback);
5861  electboardbackshape->DefineSection(0,0.0);
5862  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5863  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5864                                                                                          electboardbackshape,fSSDSupportRingAl);
5865  electboardback->SetLineColor(fColorAl);
5866  // Electronic Board Kapton Layer
5867  const Int_t kelectlayervertexnumber = 8;
5868  Double_t xelectlayer[kelectlayervertexnumber];
5869  Double_t yelectlayer[kelectlayervertexnumber];
5870  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5871  xelectlayer[1] = xelectlayer[0];
5872  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5873  xelectlayer[3] = xelectlayer[2];
5874  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5875
5876  yelectlayer[0] = 0.0;
5877  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5878  yelectlayer[2] = yelectlayer[1];
5879  yelectlayer[3] = yelectlayer[0];
5880  yelectlayer[4] = yelectlayer[3];
5881  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5882  yelectlayer[6] = yelectlayer[5];
5883  yelectlayer[7] = yelectlayer[4];
5884  TGeoXtru* electlayershape = new TGeoXtru(2);
5885  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5886  electlayershape->DefineSection(0,0.0);
5887  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5888  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5889                                                                                          electlayershape,fSSDKaptonFlexMedium);
5890  electlayer->SetLineColor(fColorKapton);
5891  // JMD Connector Female
5892  const Int_t kjmdconnectorvertexnumber = 6;
5893  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5894  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5895  xjmdconnectorvertex[0] = 0.0;
5896  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5897  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5898  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5899  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5900  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5901
5902  yjmdconnectorvertex[0] = 0.0;
5903  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5904  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5905  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5906  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5907  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5908  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5909  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5910                                                                   yjmdconnectorvertex);
5911  jmdconnectorshape->DefineSection(0,0.0);
5912  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5913  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5914                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5915  jmdconnector->SetLineColor(fColorG10);
5916  // Top Cable Connector
5917  const Int_t kcableconnectorvertexnumber = 8;
5918  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5919  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5920  xconnectorvertex[0] = 0.0;
5921  xconnectorvertex[1] = xconnectorvertex[0];
5922  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5923  xconnectorvertex[3] = xconnectorvertex[2];
5924  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5925                                          - fgkEndCapCardCableConnectorLength[2];
5926  xconnectorvertex[5] = xconnectorvertex[4];
5927  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5928  xconnectorvertex[7] = xconnectorvertex[6];
5929
5930  yconnectorvertex[0] = 0.0;
5931  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5932  yconnectorvertex[2] = yconnectorvertex[1];
5933  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5934  yconnectorvertex[4] = yconnectorvertex[3];
5935  yconnectorvertex[5] = yconnectorvertex[1];
5936  yconnectorvertex[6] = yconnectorvertex[5];
5937  yconnectorvertex[7] = yconnectorvertex[0];
5938  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5939  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5940                                                                     yconnectorvertex);
5941  cableconnectorshape->DefineSection(0,0.0);
5942  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5943  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5944                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5945  cableconnector->SetLineColor(fColorG10);
5946  // Strip Connection
5947  TGeoBBox* endcapstripconnectionshape =
5948                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5949                                                                                          0.5*fgkEndCapStripConnectionThickness,
5950                                                                                          0.5*fgkEndCapStripConnectionWidth);
5951  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5952                                                                                                         endcapstripconnectionshape,
5953                                                                                                         fSSDSupportRingAl);
5954  endcapstripconnection->SetLineColor(fColorAl);
5955  // Interface Card B
5956  const Int_t kcardBvertexnumber = 12;
5957  Double_t xcardBvertexnumber[kcardBvertexnumber];
5958  Double_t ycardBvertexnumber[kcardBvertexnumber];
5959
5960  xcardBvertexnumber[0]  = 0.0;
5961  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5962  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5963  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5964  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5965  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5966  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5967  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5968  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5969  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5970  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5971  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5972
5973  ycardBvertexnumber[0]  = 0.0;
5974  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5975  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5976  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5977  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5978  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5979  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5980  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5981  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5982  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5983  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5984  ycardBvertexnumber[11] = ycardBvertexnumber[0];
5985
5986  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5987  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5988  interfacecardBshape->DefineSection(0,0.);
5989  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5990  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5991                                                                                          fSSDMountingBlockMedium);
5992  interfacecardB->SetLineColor(46);
5993  // Interface Card B Electronic Board
5994  const Int_t kelectboardcardBvertexnumber = 14;
5995  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5996  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5997
5998  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5999  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
6000  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6001  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
6002  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6003  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
6004  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6005  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
6006  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6007  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
6008  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6009  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6010  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6011  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6012
6013  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6014  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6015  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
6016  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6017  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
6018  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
6019  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
6020  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6021  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
6022  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6023  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6024  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6025  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6026  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6027
6028  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6029  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6030                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
6031  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6032  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6033                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
6034  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6035                                                                                           fSSDSupportRingAl);
6036  electboardcardB->SetLineColor(fColorAl);
6037  // Generating Stiffener 2
6038  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6039                                                                                            0.5*fgkEndCapStiffenerThickness,
6040                                                                                            0.5*fgkEndCapStiffenerLength);
6041  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6042  endcapstiffener->SetLineColor(fColorAl);
6043  // Generating Mother Interface Card B Container
6044  const Int_t kinterfacecardBmothervertexnumber = 10;
6045  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6046  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6047
6048  xinterfacecardBmothervertex[0] = 0.0;
6049  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6050  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6051                                                                 + fgkEndCapInterfaceCardBThickness;
6052  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6053  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6054                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
6055  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6056  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6057  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6058  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6059                                                                 + fgkEndCapCardJMDConnectorLength[0];
6060  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6061
6062  yinterfacecardBmothervertex[0] = 0.0;
6063  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6064                                                                 + fgkEndCapInterfaceCardBWidth[1]
6065                                                                 + fgkEndCapInterfaceCardBWidth[2];
6066  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6067  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6068  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6069  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6070  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6071  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6072                                                                 + fgkEndCapCardJMDConnectorWidth[0]
6073                                                                 + fgkEndCapCardJMDConnectorWidth[1];
6074  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6075  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6076  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6077  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6078                                                                                   xinterfacecardBmothervertex,
6079                                                                                   yinterfacecardBmothervertex);
6080  interfacecardBmothershape->DefineSection(0,-1.e-15);
6081  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6082  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6083                                                                                                    interfacecardBmothershape,fSSDAir);
6084  electboardcardB->SetLineColor(fColorAl);
6085  // Positioning Volumes Mother Interface Card B Container
6086  TGeoRotation* interfacecardBrot = new TGeoRotation();
6087  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6088  interfacecardBrot->SetAngles(90.,-90.,-90.);
6089  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6090  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6091  TGeoRotation* electboardcardBrot = new TGeoRotation();
6092  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6093  electboardcardBrot->SetAngles(90.,90.,-90.);
6094  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6095  TGeoCombiTrans* electboardcardBcombitrans =
6096                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6097  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6098  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6099  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6100  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6101  TGeoTranslation* jmdconnectorcardBtrans[3];
6102  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6103  for(Int_t i=0; i<3; i++){
6104    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6105                                                          + fgkEndCapCardJMDConnectorLength[0],
6106                                                            fgkEndCapCardElectBoardLayerWidth[1],
6107                                                            0.5*fgkEndCapCardJMDConnectorThickness
6108                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6109                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6110                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6111    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6112                                                                                                            *jmdconnectorcardBrot);
6113    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6114  }
6115  // Mother Supply Card Container
6116  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6117  // Interface Card Container
6118  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6119  // Placing Volumes in Mother Supply Card Container
6120  // JMD Connector Positioning
6121  TGeoTranslation* jmdconnectortrans[2];
6122  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6123  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6124                                                                                         fgkEndCapCardElectBoardBackLength[0]
6125                                           -                                             fgkEndCapCardJMDConnectorThickness
6126                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6127  TGeoRotation* jmdconnectorot = new TGeoRotation();
6128  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6129                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6130                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6131                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6132                                                                       fgkEndCapCardJMDConnectorThickness
6133                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6134  jmdconnectorot->SetAngles(90.,180.,-90);
6135  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6136                                                                                 * jmdconnectorot);
6137  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6138  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6139  // Top Cable Connector Placing
6140  TGeoRotation* cableconnectorot[2];
6141  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6142  TGeoTranslation* cableconnectortrans[3];
6143  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6144  cableconnectorot[0]->SetAngles(90.,0.,0.);
6145  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6146  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6147  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6148                                                                                                                            *cableconnectorot[0]);
6149  TGeoHMatrix* cableconnectormatrix[2];
6150  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6151                                                         new TGeoHMatrix((*cableconnectorot[1])
6152                                                                                    *(*cableconnectorcombitrans));
6153  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6154                                            -                               fgkEndCapCardCableConnectorThickness,
6155                                                                                 fgkEndCapCardCableConnectorLength[0]
6156                                            +                            fgkEndCapCardCableConnectorToLayer);
6157  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6158                                            -                2.*fgkEndCapCardCableConnectorThickness
6159                                            -                            fgkEndCapCardCableConnectorDistance,
6160                                                                                 fgkEndCapCardCableConnectorLength[0]
6161                                            +                            fgkEndCapCardCableConnectorToLayer);
6162  for(Int_t i=0; i<2; i++){
6163         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6164     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6165  }
6166  TGeoRotation* electboardbackrot = new TGeoRotation();
6167  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6168  electboardbackrot->SetAngles(90.,-90.,-90.);
6169  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6170                                                         +                fgkEndCapCardJMDConnectorLength[0]
6171                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6172  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6173                                                                                                                            *electboardbackrot);
6174  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6175  // Electronic Board Kapton Layer Positioning
6176  TGeoRotation* electlayerrot = new TGeoRotation();
6177  TGeoTranslation* electlayertrans[2];
6178  TGeoCombiTrans* electlayercombitrans[2];
6179  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6180  electlayerrot->SetAngles(90.,-90.,-90.);
6181  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6182                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6183  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6184                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6185                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6186  for(Int_t i=0; i<2; i++){
6187         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6188         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6189  }
6190  // Placing Volumes in Mother Interface Card Container
6191  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6192  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6193  for(Int_t i=0; i<2; i++){
6194         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6195  }
6196  /////////////////////////////////////////////////////////////
6197  // Generation of Card Interface Container
6198  /////////////////////////////////////////////////////////////
6199  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6200                                                   - fgkEndCapCardJMDConnectorLength[0]
6201                                                   - fgkEndCapInterfaceCardBThickness
6202                                                   - 9.*fgkEndCapStripConnectionThickness
6203                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6204  const Int_t kcardinterfacecontainervertexnumber = 14;
6205  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6206  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6207  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6208                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6209  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6210  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6211                                                                    + fgkEndCapStripConnectionThickness
6212                                                                    - fgkEndCapCardElectBoardLayerThickness
6213                                                                    - fgkEndCapCardCableConnectorWidth[0];
6214  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6215  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6216  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6217  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6218                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6219  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6220  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6221                                                                    + fgkEndCapInterfaceCardBThickness;
6222  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6223  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6224                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6225  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6226  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6227                                    - fgkEndCapInterfaceElectBoardCardBThickness
6228                                                                    + fgkEndCapCardJMDConnectorLength[0]
6229                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6230  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6231
6232  ycardinterfacecontainervertex[0]  = 0.;
6233  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6234                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6235                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6236  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6237  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6238                                                                    - fgkEndCapStripConnectionWidth;
6239  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6240  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6241  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6242  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6243                                                                    + fgkEndCapInterfaceCardBWidth[1]
6244                                                                    + fgkEndCapInterfaceCardBWidth[2];
6245  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6246  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6247  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6248  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6249  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6250  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6251
6252  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6253  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6254                                                                                   xcardinterfacecontainervertex,
6255                                                                                   ycardinterfacecontainervertex);
6256  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6257                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6258  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6259                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6260  TGeoVolume** cardinterfacecontainer;
6261  cardinterfacecontainer = new TGeoVolume*[4];
6262  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6263                                                                                         interfacecardmothershape,fSSDAir);
6264  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6265                                                                                         interfacecardmothershape,fSSDAir);
6266  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6267                                                                                         interfacecardmothershape,fSSDAir);
6268  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6269                                                                                         interfacecardmothershape,fSSDAir);
6270  /////////////////////////////////
6271  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6272  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6273  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6274  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6275  /////////////////////////////////
6276  TGeoRotation* endcapstripconnectionrot[2];
6277  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6278  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6279  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6280  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6281                                                                         *                                 (*endcapstripconnectionrot[0]));
6282  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6283  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6284                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6285                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6286                                                                                         -endcapstripconnectionshape->GetDZ(),
6287                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6288  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6289  TGeoTranslation* cardinterfacetrans[9];
6290  TGeoHMatrix* cardinterfacematrix[9];
6291  for(Int_t i=0; i<7; i++){
6292         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6293                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6294                                                                                                 0.0,0.0);
6295         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6296                                                    *                             (*endcapstripconnectionmatrix));
6297  }
6298  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6299                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6300                                                                                                 0.0,0.0);
6301  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6302                                                 *                                 (*endcapstripconnectionmatrix));
6303  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6304                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6305                                                                                                 0.0,0.0);
6306  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6307                                                 *                                 (*endcapstripconnectionmatrix));
6308
6309  for(Int_t i=0; i<4; i++){
6310         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6311                                                                            cardinterfacematrix[7]);
6312         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6313                                                                            cardinterfacematrix[8]);
6314  }
6315  TGeoTranslation* mothersupplycardtrans =
6316                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6317                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6318                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6319  TGeoHMatrix* mothersupplycardmatrix[7];
6320  Int_t index[4] = {1,1,1,1};
6321  for(Int_t i=0; i<7; i++){
6322         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6323                                                         *                                 (*mothersupplycardtrans));
6324         for(Int_t j=0; j<4; j++){
6325                 switch(j){
6326                         case 0: //Layer5 EndCap Left Side
6327                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6328                                                                                                    cardinterfacematrix[i]);
6329                                 if(i!=0){
6330                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6331                                                                                                            mothersupplycardmatrix[i]);
6332                                         index[j]++;
6333
6334                                 }
6335                         break;
6336                         case 1: //Layer5 EndCap Rigth Side
6337                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6338                                                                                                    cardinterfacematrix[i]);
6339                                 if(i>0&&i<6){
6340                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6341                                                                                                            mothersupplycardmatrix[i]);
6342                                         index[j]++;
6343                                 }
6344                         break;
6345                         case 2: //Layer6 EndCap Left Side
6346                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6347                                                                                                    cardinterfacematrix[i]);
6348                                 if(i!=6){
6349                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6350                                                                                                            mothersupplycardmatrix[i]);
6351                                         index[j]++;
6352                                 }
6353                         break;
6354                         case 3: //Layer6 EndCap Right Side
6355                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6356                                                                                                    cardinterfacematrix[i]);
6357                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6358                                                                                                    mothersupplycardmatrix[i]);
6359                                 index[j]++;
6360                         break;
6361                 }
6362         }
6363  }
6364  // Positioning Interface
6365  TGeoTranslation* motherinterfacecardtrans =
6366                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6367                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6368                                                          -fgkEndCapCardElectBoardLayerThickness
6369                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6370  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6371                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6372  // Positioning Interface Card B
6373  TGeoTranslation* interfacecardBmothertrans =
6374                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6375                                                                                 + 2.*fgkEndCapStripConnectionThickness
6376                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6377                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6378                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6379  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6380                                                                                                                          interfacecardBmothertrans);
6381  // Positioning Stiffener
6382  TGeoTranslation* endcapstiffenertrans =
6383                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6384                                                                            +    2.0*fgkEndCapStripConnectionThickness
6385                                                                            +    fgkEndCapInterfaceCardBThickness
6386                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6387                                                                            +    stiffenertransx
6388                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6389                                                                                         endcapstiffenershape->GetDZ()
6390                                                                            -    0.5*(fgkEndCapStiffenerLength
6391                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6392  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6393  /////////////////////////////////////////////////////////////
6394  // Deallocating memory
6395  /////////////////////////////////////////////////////////////
6396  delete interfacecardBrot;
6397  delete interfacecardBtrans;
6398  delete electboardcardBtrans;
6399  delete electboardcardBrot;
6400  delete jmdconnectorcardBrot;
6401  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6402  delete jmdconnectorot;
6403  delete jmdconnectortrans[1];
6404  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6405  delete cableconnectorcombitrans;
6406  delete electboardbacktrans;
6407  delete electboardbackrot;
6408  delete electlayerrot;
6409  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6410  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6411  delete mothersupplycardtrans;
6412  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6413  /////////////////////////////////////////////////////////////
6414  return cardinterfacecontainer;
6415  }
6416  ////////////////////////////////////////////////////////////////////////////////
6417  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6418   /////////////////////////////////////////////////////////////
6419   // Method returning EndCap Mother Volume
6420   /////////////////////////////////////////////////////////////
6421   const Int_t kendcapcoverplatesmallholenumber = 9;
6422   Double_t endcapmotherorigin[3];
6423   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6424                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6425                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6426   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6427                                           -                      fgkEndCapCoverPlateWidth[2]
6428                                           -       (kendcapcoverplatesmallholenumber-1)
6429                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6430                                           +  0.5*(fgkEndCapSideCoverLength[2]
6431                                           +               fgkEndCapCoverPlateWidth[1]
6432                                           -       fgkEndCapCoverPlateWidth[0])
6433                                           -      (fgkEndCapCoverPlateWidth[1]
6434                                           -       fgkEndCapCoverPlateWidth[0]);
6435   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6436                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6437                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6438                                                 +      fgkEndCapSideCoverWidth[1]
6439                                                 +      fgkEndCapSideCoverThickness
6440                                                 +      fgkEndCapKaptonFoilThickness);
6441   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6442                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6443                                                           +              2.0* fgkEndCapSideCoverThickness),
6444                                                                          0.5* (fgkEndCapSideCoverLength[2]
6445                                                           +                    fgkEndCapCoverPlateWidth[1]
6446                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6447                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6448                                                       +                                    fgkEndCapSideCoverWidth[1]
6449                                                           +                                       fgkEndCapSideCoverThickness
6450                                                       +                                   fgkEndCapKaptonFoilThickness),
6451                                                                                          endcapmotherorigin);
6452   TGeoVolume** endcapassembly;
6453   endcapassembly = new TGeoVolume*[4];
6454   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6455                                                                                         endcapmothershape,fSSDAir);
6456   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6457                                                                                         endcapmothershape,fSSDAir);
6458   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6459                                                                                         endcapmothershape,fSSDAir);
6460   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6461                                                                                         endcapmothershape,fSSDAir);
6462  /////////////////////////////////
6463  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6464  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6465  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6466  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6467  /////////////////////////////////
6468   /////////////////////////////////////////////////////
6469   // Placing Endcap Cover Plate
6470   /////////////////////////////////////////////////////
6471   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6472   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6473   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6474   TGeoCombiTrans* endcapcoverplatecombitrans =
6475                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6476                                                                                          endcapcoverplaterot);
6477   TGeoTranslation* endcapcoverplatetrans =
6478                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6479   TGeoHMatrix* endcapcoverplatematrix =
6480                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6481                                                                           *       (*endcapcoverplatecombitrans));
6482   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6483   /////////////////////////////////////////////////////
6484   // Placing Endcap Side Cover
6485   /////////////////////////////////////////////////////
6486   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6487   TGeoRotation* endcapsidecoverot[2];
6488   TGeoCombiTrans* endcapsidecovercombitrans[3];
6489   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6490   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6491   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6492                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6493                                                                                         - fgkEndCapCoverPlateWidth[2]
6494                                                                                     - (kendcapcoverplatesmallholenumber-1)
6495                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6496                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6497                                                                                         + fgkEndCapSideCoverLength[2],
6498                                                                                           0.5*(fgkEndCapSideCoverThickness
6499                                                                                         + fgkEndCapCoverPlateThickness)
6500                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6501                                                                                           endcapsidecoverot[0]);
6502   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6503   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6504                                                                                                         0.5*fgkEndCapCoverPlateThickness
6505                                                                                                         -fgkEndCapSideCoverWidth[1],
6506                                                                                                         endcapsidecoverot[1]);
6507   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6508                                                                                                         +fgkEndCapCoverPlateLength[3]
6509                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6510                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6511                                                                                                         0.5*fgkEndCapCoverPlateThickness
6512                                                                                                         -fgkEndCapSideCoverWidth[1],
6513                                                                                                         endcapsidecoverot[1]);
6514   TGeoHMatrix* endcapsidecovermatrix[2];
6515   for(Int_t i=0; i<2; i++){
6516    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6517                                                         *                                 (*endcapsidecovercombitrans[0]));
6518         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6519                                                                                                                 endcapsidecovermatrix[i]);
6520   }
6521   /////////////////////////////////////////////////////
6522   // Placing Endcap Cooling Tube
6523   /////////////////////////////////////////////////////
6524   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6525   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6526   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6527   TGeoCombiTrans* endcapccolingtubecombitrans
6528                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6529                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6530                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6531                                                 - fgkEndCapCoolingTubeToCoverSide,
6532                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6533                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6534   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6535                                                                                                           endcapccolingtubecombitrans);
6536   /////////////////////////////////////////////////////
6537   // Placing Screws
6538   /////////////////////////////////////////////////////
6539   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6540                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6541   Int_t screwcoverplatedgesnumber[2] = {20,20};
6542   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6543                                                                                 fgkEndCapCoverPlateThickness
6544                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6545   TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6546                                                                                                  screwcoverplatedgesnumber,
6547                                                                                                  screwcoverplatesection);
6548   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6549                                                                                            screwcoverplateshape,
6550                                                                                            fSSDCoolingTubePhynox);
6551   screwcoverplate->SetLineColor(12);
6552   Double_t transx[4] = {0,
6553                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6554                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6555                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6556                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6557                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6558   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6559 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6560   TGeoTranslation*** endcapcoverplatescrewtrans;
6561   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6562   Int_t index = 0;
6563   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6564         endcapcoverplatescrewtrans[i] =
6565                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6566     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6567                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6568         if(index==1||index==9||index==28||index==36){
6569                         endcapcoverplatescrewtrans[i][j] =
6570                                 new TGeoTranslation(transx[i],
6571                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6572                                                                         fgkEndCapSideCoverThickness);
6573                 }
6574                 else{
6575                         endcapcoverplatescrewtrans[i][j] =
6576                                 new TGeoTranslation(transx[i],
6577                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6578                                                                         0.);
6579                 }
6580             if(index!=19)
6581                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6582                                                                                           endcapcoverplatescrewtrans[i][j]);
6583         }
6584   }
6585   /////////////////////////////////////////////////////
6586   // Placing Cover Plate Clips
6587   /////////////////////////////////////////////////////
6588   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6589                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6590                                                                                                          0.5*fgkEndCapSideCoverThickness);
6591   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6592                                                                                                         endcapcoverplateclipshape,
6593                                                                                                         fSSDCoolingTubePhynox);
6594   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6595                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6596                                                                                                          0.5*fgkEndCapSideCoverThickness);
6597   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6598                                                                                                         endcapcoverplatedownclipshape,
6599                                                                                                         fSSDCoolingTubePhynox);
6600   TGeoTranslation* endcapcoverplatecliptrans[4];
6601   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6602                                                            -                     fgkEndCapCoverPlateLength[0]
6603                                                            -                     fgkEndCapSideCoverThickness,
6604                                                                                                          0.0,
6605                                                                                                  0.5*(fgkEndCapSideCoverThickness
6606                                                            +                                              fgkEndCapCoverPlateThickness));
6607   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6608                                                            -                     fgkEndCapCoverPlateLength[0]
6609                                                            -                     fgkEndCapSideCoverThickness,
6610                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6611                                                            *                                     fgkEndCapSideCoverWidth[5],
6612                                                                                                  0.5*(fgkEndCapSideCoverThickness
6613                                                            +                                              fgkEndCapCoverPlateThickness));
6614   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6615                                                            -                     fgkEndCapCoverPlateLength[0]
6616                                                            +                                     fgkEndCapCoverPlateLength[1]
6617                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6618                                                            -                                     fgkEndCapCoverPlateClipLength
6619                                                            +                                 fgkEndCapSideCoverThickness,
6620                                                                                                          0.0,
6621                                                                                                  0.5*(fgkEndCapSideCoverThickness
6622                                                            +                                              fgkEndCapCoverPlateThickness));
6623   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6624                                                            -                     fgkEndCapCoverPlateLength[0]
6625                                                            +                                     fgkEndCapCoverPlateLength[1]
6626                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6627                                                            -                                     fgkEndCapCoverPlateClipLength
6628                                                            +                                 fgkEndCapSideCoverThickness,
6629                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6630                                                            *                                     fgkEndCapSideCoverWidth[5],
6631                                                                                                  0.5*(fgkEndCapSideCoverThickness
6632                                                            +                                              fgkEndCapCoverPlateThickness));
6633   endcapcoverplateclip->SetLineColor(fColorPhynox);
6634   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6635   for(Int_t i=0; i<4; i++)
6636         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6637                                                                                                    endcapcoverplatecliptrans[i]);
6638   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6639   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6640                                                                    -                     fgkEndCapCoverPlateLength[0]
6641                                                                    -                     fgkEndCapSideCoverThickness,
6642                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6643                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6644                                                                                                         0.5*(fgkEndCapSideCoverThickness
6645                                                                +                                         fgkEndCapCoverPlateThickness)
6646                                                                    -                     fgkEndCapSideCoverWidth[1]
6647                                                                    -                                     fgkEndCapSideCoverThickness);
6648   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6649                                                                    -                     fgkEndCapCoverPlateLength[0]
6650                                                                    -                     fgkEndCapSideCoverThickness,
6651                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6652                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6653                                                                    +                            fgkEndCapSideCoverLength[2]
6654                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6655                                                                                                         0.5*(fgkEndCapSideCoverThickness
6656                                                                +                                         fgkEndCapCoverPlateThickness)
6657                                                                    -                     fgkEndCapSideCoverWidth[1]
6658                                                                    -                                     fgkEndCapSideCoverThickness);
6659   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6660                                                                    -                     fgkEndCapCoverPlateLength[0]
6661                                                                    +                     fgkEndCapSideCoverThickness
6662                                                                    +                     fgkEndCapCoverPlateLength[1]
6663                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6664                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6665                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6666                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6667                                                                                                         0.5*(fgkEndCapSideCoverThickness
6668                                                                +                                         fgkEndCapCoverPlateThickness)
6669                                                                    -                     fgkEndCapSideCoverWidth[1]
6670                                                                    -                                     fgkEndCapSideCoverThickness);
6671   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6672                                                                    -                     fgkEndCapCoverPlateLength[0]
6673                                                                    +                     fgkEndCapSideCoverThickness
6674                                                                    +                     fgkEndCapCoverPlateLength[1]
6675                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6676                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6677                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6678                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6679                                                                    +                                 fgkEndCapSideCoverLength[2]
6680                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6681                                                                                                         0.5*(fgkEndCapSideCoverThickness
6682                                                                +                                         fgkEndCapCoverPlateThickness)
6683                                                                    -                     fgkEndCapSideCoverWidth[1]
6684                                                                    -                                     fgkEndCapSideCoverThickness);
6685   for(Int_t i=0; i<4; i++)
6686         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6687                                                                                                    endcapcoverplatedowncliptrans[i]);
6688   /////////////////////////////////////////////////////
6689   // Placing Kapton Foil
6690   /////////////////////////////////////////////////////
6691   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6692                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6693                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6694   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6695                                                                                                 endcapkaptonfoilshape,
6696                                                                                                 fSSDKaptonFlexMedium);
6697   endcapkaptonfoil->SetLineColor(8);
6698   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6699                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6700                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6701                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6702                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6703                                                                              -                     fgkEndCapSideCoverWidth[1]
6704                                                                                  -                     fgkEndCapSideCoverThickness);
6705   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6706   /////////////////////////////////////////////////////////////
6707   // Placing Electronic Tubes
6708   /////////////////////////////////////////////////////////////
6709   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6710                                                                              - fgkEndCapInterfaceCardBThickness
6711                                                                              - 9.*fgkEndCapStripConnectionThickness
6712                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6713                                                                                fgkEndCapKaptonFoilWidth
6714                                                                              - fgkEndCapInterfaceCardBThickness
6715                                                                              - 9.*fgkEndCapStripConnectionThickness
6716                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6717                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6718   TGeoVolume* endcapeffectivecables[2];
6719   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6720                                                                                          fgkEndCapEffectiveCableRadiusMax,
6721                                                                                          endcapeffectivecableswidth[0],
6722                                                                                          10,"EndCapEffectiveCables1");
6723   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6724                                                                                          fgkEndCapEffectiveCableRadiusMax,
6725                                                                                          endcapeffectivecableswidth[1],
6726                                                                                          25,"EndCapEffectiveCables2");
6727   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6728   TGeoTranslation* endcapeffectivecablestrans[2];
6729   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6730                                           -                                                        0.5*endcapeffectivecableswidth[0]
6731                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6732                                           -                                                               fgkEndCapCoverPlateWidth[2]
6733                                           -                                             (kendcapcoverplatesmallholenumber-1)
6734                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6735                                           +                                             fgkEndCapSideCoverLength[2],
6736                                           -                     0.5*fgkEndCapCoverPlateThickness
6737                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6738                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6739                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6740   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6741                                           -                                                        0.5*endcapeffectivecableswidth[1]
6742                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6743                                           -                                                               fgkEndCapCoverPlateWidth[2]
6744                                           -                                             (kendcapcoverplatesmallholenumber-1)
6745                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6746                                           +                                         fgkEndCapSideCoverLength[2],
6747                                           -                     0.5*fgkEndCapCoverPlateThickness
6748                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6749                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6750                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6751   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6752   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6753   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6754                                                                                                                    *endcapeffectivecablesrot);
6755   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6756                                                                                                                    *endcapeffectivecablesrot);
6757   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6758                                                                                                           endcapeffectivecablescombitrans[0]);
6759   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6760                                                                                                           endcapeffectivecablescombitrans[1]);
6761   /////////////////////////////////////////////////////////////
6762   // Placing End Cap Cards
6763   /////////////////////////////////////////////////////////////
6764   TGeoVolume** endcapcards = GetEndCapCards();
6765   TGeoRotation* endcapcardsrot[2];
6766   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6767   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6768   TGeoTranslation* endcapcardstrans[2];
6769   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6770                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6771   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6772   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6773   TGeoHMatrix* endcapcardsmatrix[2];
6774   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6775   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6776                                                   - fgkEndCapCardJMDConnectorLength[0]
6777                                                   - fgkEndCapInterfaceCardBThickness
6778                                                   - 9.*fgkEndCapStripConnectionThickness
6779                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6780   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6781                                           -                                             fgkEndCapCoverPlateLength[0]
6782                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6783                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6784                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6785                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6786                                           -                                                               fgkEndCapInterfaceCardBThickness
6787                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6788                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6789                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6790                                           -                                                               fgkEndCapCoverPlateWidth[2]
6791                                           -                                             (kendcapcoverplatesmallholenumber-1)
6792                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6793                                           +                     fgkEndCapKaptonFoilWidth,
6794                                                                                           0.5*fgkEndCapCoverPlateThickness
6795                                           -                                                     fgkEndCapSideCoverWidth[1]);
6796   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6797   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6798    /////////////////////////////////////////////////////////////
6799   // Deallocating memory
6800   /////////////////////////////////////////////////////////////
6801   delete endcapcoverplaterot;
6802   delete endcapcoverplatecombitrans;
6803   delete endcapcoverplatetrans;
6804   for(Int_t i=0; i<3; i++){
6805    delete endcapsidecovercombitrans[i];
6806    if(i<2) delete endcapsidecoverot[i];
6807   }
6808   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6809   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6810   delete endcapcardsmatrix[0];
6811   return endcapassembly;
6812  }
6813  ////////////////////////////////////////////////////////////////////////////////
6814  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6815                                                                                                                         Double_t radiusmax,
6816                                                                                                                         Double_t width,
6817                                                                                                                         Int_t ncables,
6818                                                                                                                         char* volname){
6819   /////////////////////////////////////////////////////////////
6820   // Generating EndCap High Voltage Tubes
6821   /////////////////////////////////////////////////////////////
6822   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6823   Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6824                                                            +             TMath::Power(radiusmax,2.)
6825                                -             TMath::Power(radiusmin,2.));
6826   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6827   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6828                                                                                                    effectiveouteradius,0.5*width);
6829   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6830                                                                                                 effectiveinnertubeshape,
6831                                                                                                 fSSDStiffenerConnectorMedium);
6832   effectiveinnertube->SetLineColor(41);
6833   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6834                                                                                                 effectiveoutertubeshape,
6835                                                                                                 fSSDKaptonChipCableMedium);
6836   effectiveoutertube->SetLineColor(39);
6837   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6838   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6839   effectivemothertube->AddNode(effectiveinnertube,1);
6840   effectivemothertube->AddNode(effectiveoutertube,1);
6841   return effectivemothertube;
6842  }
6843  ////////////////////////////////////////////////////////////////////////////////
6844  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6845   /////////////////////////////////////////////////////////////
6846   // Generating EndCap Support Layer 5 and Layer 6
6847   /////////////////////////////////////////////////////////////
6848   const Int_t knedges = 5;
6849   ///////////////////////////////////////////////
6850   // Setting the vertices for TGeoXtru Up Volume
6851   ///////////////////////////////////////////////
6852   const Int_t klayernumber = 2;
6853   Double_t xupvertex[klayernumber][knedges+3];
6854   Double_t yupvertex[klayernumber][knedges+3];
6855   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6856   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6857   Double_t middlepsi[klayernumber] = {0.0,0.0};
6858   for(Int_t i=0; i<klayernumber; i++){
6859         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6860         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6861         xupvertex[i][2] = -xupvertex[i][1];
6862         xupvertex[i][3] = -xupvertex[i][0];
6863
6864         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6865         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6866         yupvertex[i][2] =  yupvertex[i][1];
6867         yupvertex[i][3] =  yupvertex[i][0];
6868
6869     middledgeangle[i] = upedgeangle[i]/knedges;
6870     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6871     for(Int_t j=1; j<knedges; j++){
6872                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6873                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6874         }
6875   }
6876   ////////////////////////////////////
6877   // Generating Up TGeoXtru
6878   ////////////////////////////////////
6879   TGeoXtru* upendcapsupportshape[klayernumber];
6880   TGeoVolume* upendcapsupport[klayernumber];
6881   char upendcapsupportname[30];
6882   for(Int_t i=0; i<klayernumber; i++){
6883    upendcapsupportshape[i] = new TGeoXtru(2);
6884    sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6885    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6886    upendcapsupportshape[i]->DefineSection(0,0.);
6887    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6888    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6889                                                                         fSSDCoolingTubePhynox);
6890 //   upendcapsupport[i]->SetLineColor(fColorPhynox);
6891    upendcapsupport[i]->SetLineColor(5);
6892   }
6893   ///////////////////////////////////////////////
6894   // Setting the vertices for TGeoXtru Down Volume
6895   ///////////////////////////////////////////////
6896   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6897   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6898   for(Int_t i=0; i<klayernumber; i++){
6899         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6900         xdownvertex[i][1] =  xupvertex[i][0];
6901         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6902         ydownvertex[i][1] =  yupvertex[i][0];
6903         for(Int_t j=0; j<knedges; j++){
6904                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6905                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6906         }
6907         for(Int_t j=0; j<knedges; j++){
6908                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6909                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6910                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6911                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6912         }
6913   }
6914   ////////////////////////////////////
6915   // Generating Down TGeoXtru
6916   ////////////////////////////////////
6917   TGeoXtru* downendcapsupportshape[klayernumber];
6918   TGeoVolume* downendcapsupport[klayernumber];
6919   char downendcapsupportname[30];
6920   for(Int_t i=0; i<klayernumber; i++){
6921         downendcapsupportshape[i] = new TGeoXtru(2);
6922     sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6923         downendcapsupportshape[i] = new TGeoXtru(2);
6924         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6925     if(i==0){
6926                 downendcapsupportshape[i]->DefineSection(0,0.);
6927                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6928     }
6929         else{
6930                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6931                                                                  -                 fgkEndCapSupportLowWidth[i]);
6932                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6933         }
6934     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6935                                                                 downendcapsupportshape[i],fSSDCoolingTubePhynox);
6936 //      downendcapsupport[i]->SetLineColor(fColorPhynox);
6937         downendcapsupport[i]->SetLineColor(5);
6938   }
6939   ///////////////////////////////////////////////
6940   // Setting TGeoPgon Volume
6941   ///////////////////////////////////////////////
6942   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6943                                                                                                    fgkSSDLay6LadderNumber};
6944   TGeoPgon* endcapsupportmothershape[klayernumber];
6945   TGeoVolume** endcapsupportmother;
6946   endcapsupportmother = new TGeoVolume*[klayernumber];
6947   char endcapsupportmothername[30];
6948   for(Int_t i=0; i<klayernumber; i++){
6949         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6950     sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6951         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6952     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6953                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6954     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6955                                                                                         fSSDCoolingTubePhynox);
6956   }
6957   ////////////////////////////////////
6958   TGeoRotation** endcapsupportrot[klayernumber];
6959   for(Int_t i=0; i<2; i++){
6960         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6961         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6962            endcapsupportrot[i][j] = new TGeoRotation();
6963            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6964        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6965        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6966         }
6967   }
6968   return endcapsupportmother;
6969  }
6970  ////////////////////////////////////////////////////////////////////////////////
6971  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6972   /////////////////////////////////////////////////////////////
6973   // Setting End Cap Support Layer 5 and 6.
6974   /////////////////////////////////////////////////////////////
6975   const Int_t kendcapcoverplatesmallholenumber = 9;
6976   const Int_t klayernumber = 2;
6977   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6978                                                                                                    fgkSSDLay6LadderNumber};
6979   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6980                                                                                 360.0/kssdlayladdernumber[1]};
6981   TGeoVolume** endcapsupport = EndCapSupport();
6982   TGeoVolume** endcapassembly = GetEndCapAssembly();
6983   TGeoPgon* endcapsupportshape[klayernumber];
6984   Double_t* radiusmin[klayernumber];
6985   Double_t* radiusmax[klayernumber];
6986   for(Int_t i=0; i<klayernumber; i++){
6987     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6988         radiusmin[i] = endcapsupportshape[i]->GetRmin();
6989         radiusmax[i] = endcapsupportshape[i]->GetRmax();
6990   }
6991   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6992   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6993                                                                           endcapassemblyshape->GetDY(),
6994                                                                           endcapassemblyshape->GetDZ()};
6995   ///////////////////////////////////////////////
6996   // Setting TGeoPgon Volume for Mother Container
6997   ///////////////////////////////////////////////
6998   TGeoPgon* endcapsupportsystemshape[klayernumber];
6999   char endcapsupportsystemothername[30];
7000   for(Int_t i=0; i<klayernumber; i++){
7001         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7002     sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7003         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7004                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7005                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7006                                                                                            +2.*endcapassemblycenter[2])
7007                                                                                            /CosD(0.5*upedgeangle[i]));
7008     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7009                                                                                                  -(fgkEndCapCoverPlateWidth[1]
7010                                                                                              - fgkEndCapCoverPlateWidth[0]),
7011                                                                                            *radiusmin[i],
7012                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7013                                                                                            +2.*endcapassemblycenter[2])
7014                                                                                            /CosD(0.5*upedgeangle[i]));
7015   }
7016   fgkEndCapSupportSystem = new TGeoVolume*[4];
7017   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7018                                                                           endcapsupportsystemshape[0],fSSDAir);
7019   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7020                                                                           endcapsupportsystemshape[0],fSSDAir);
7021   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7022                                                                           endcapsupportsystemshape[1],fSSDAir);
7023   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7024                                                                           endcapsupportsystemshape[1],fSSDAir);
7025   ///////////////////////////////////////////////
7026   TGeoTranslation* endcapassemblytrans[klayernumber];
7027   for(Int_t i=0; i<klayernumber; i++)
7028         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7029                                                                            -  fgkEndCapSideCoverThickness
7030                                                                            +  endcapassemblycenter[0],
7031                                                                            -  0.5*fgkEndCapCoverPlateThickness
7032                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
7033                                                                            +  2.0*endcapassemblycenter[2]
7034                                                                            +  0.5*fgkEndCapSupportLength[i]
7035                                                                            /  TanD(0.5*upedgeangle[i]),
7036                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
7037                                                                            -  fgkEndCapCoverPlateWidth[2]
7038                                                                            - (kendcapcoverplatesmallholenumber-1)
7039                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
7040   TGeoRotation** endcapassemblyrot[klayernumber];
7041   TGeoHMatrix** endcapassemblymatrix[klayernumber];
7042   for(Int_t i=0; i<klayernumber; i++){
7043    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7044    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7045    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7046    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7047    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7048    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7049    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7050    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7051         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7052         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7053    }
7054   }
7055   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7056                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7057   for(Int_t i=0; i<2*klayernumber; i++){
7058         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7059                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7060                                                                                                                                            endcapassemblymatrix[1][j+2]);
7061         }
7062         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7063   }
7064    /////////////////////////////////////////////////////////////
7065   // Deallocating memory
7066   /////////////////////////////////////////////////////////////
7067   for(Int_t i=0; i<klayernumber; i++){
7068         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7069                 delete endcapassemblyrot[i][j];
7070         }
7071         delete endcapassemblyrot[i];
7072         delete endcapassemblymatrix[i][0];
7073         delete endcapassemblymatrix[i][1];
7074   }
7075   /////////////////////////////////////////////////////////////
7076   }
7077   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7078   /////////////////////////////////////////////////////////////
7079   // Setting End Cap Support + End Cap Assembly of Layer 5.
7080   /////////////////////////////////////////////////////////////
7081   if (! moth) {
7082     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7083     return;
7084   };
7085   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7086   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7087   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7088                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
7089                                                                            +            fgkEndCapSupportCenterLay5Position
7090                                                                            -            fgkEndCapSideCoverLength[2]);
7091   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7092                                                                                                 fgkEndCapSideCoverLength[2]
7093                                                                            -        fgkEndCapSupportCenterLay5Position
7094                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
7095   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7096   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7097   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7098         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7099   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7100   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7101    /////////////////////////////////////////////////////////////
7102   // Deallocating memory
7103   /////////////////////////////////////////////////////////////
7104   delete endcapsupportsystemrot;
7105   delete endcapsupportsystemITSCentertrans[1];
7106  }
7107   /////////////////////////////////////////////////////////////
7108   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7109   /////////////////////////////////////////////////////////////
7110   // Setting End Cap Support + End Cap Assembly of Layer 6.
7111   /////////////////////////////////////////////////////////////
7112   if (! moth) {
7113     printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7114     return;
7115   };
7116   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7117   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7118   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7119                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7120                                                                            +            fgkEndCapSupportCenterLay6Position
7121                                                                            -            fgkEndCapSideCoverLength[2]);
7122   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7123                                                                                                 fgkEndCapSideCoverLength[2]
7124                                                                            -        fgkEndCapSupportCenterLay6Position
7125                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7126   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7127   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7128   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7129         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7130   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7131   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7132    /////////////////////////////////////////////////////////////
7133   // Deallocating memory
7134   /////////////////////////////////////////////////////////////
7135   delete endcapsupportsystemrot;
7136   delete endcapsupportsystemITSCentertrans[1];
7137  }
7138  ////////////////////////////////////////////////////////////////////////////////
7139  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7140   /////////////////////////////////////////////////////////////
7141   // Setting Ladder Support of Layer 5.
7142   /////////////////////////////////////////////////////////////
7143   if (! moth) {
7144     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7145     return;
7146   };
7147   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7148   fMotherVol = moth;
7149   TGeoTranslation* centerITSRingSupportLay5trans[2];
7150   for(Int_t i=0; i<2; i++){
7151         centerITSRingSupportLay5trans[i] =
7152                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7153     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7154   }
7155  }
7156  ////////////////////////////////////////////////////////////////////////////////
7157  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7158   /////////////////////////////////////////////////////////////
7159   // Setting Ladder Support of Layer 6.
7160   /////////////////////////////////////////////////////////////
7161   if (! moth) {
7162     printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7163     return;
7164   };
7165   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7166   fMotherVol = moth;
7167   TGeoTranslation* centerITSRingSupportLay6trans[2];
7168   for(Int_t i=0; i<2; i++){
7169         centerITSRingSupportLay6trans[i] =
7170                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7171     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7172   }
7173  }
7174  ////////////////////////////////////////////////////////////////////////////////
7175 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7176                                                                         Double_t height, char* shapename, Int_t isign) const{
7177   /////////////////////////////////////////////////////////////
7178   // Method generating an Arb shape
7179   /////////////////////////////////////////////////////////////
7180   const Int_t kvertexnumber = 8;
7181   const Int_t ktransvectnumber = 2;
7182   TVector3* vertex[kvertexnumber];
7183   TVector3* transvector[2];
7184   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7185   /////////////////////////////////////////////////////////////
7186   //Setting the vertices for TGeoArb8
7187   /////////////////////////////////////////////////////////////
7188   vertex[0] = new TVector3(*vertexpos[0]);
7189   vertex[1] = new TVector3(*vertexpos[1]);
7190   vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7191   vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7192   vertex[4] = new TVector3(*vertexpos[2]);
7193   vertex[5] = new TVector3(*vertexpos[3]);
7194   vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7195   vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7196   /////////////////////////////////////////////////////////////
7197   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7198   for(Int_t i = 0; i<kvertexnumber;i++)
7199                                                         arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
7200   /////////////////////////////////////////////////////////////
7201   // Deallocating memory
7202   /////////////////////////////////////////////////////////////
7203   for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7204   for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7205   /////////////////////////////////////////////////////////////
7206   return arbshape;
7207 }
7208 ///////////////////////////////////////////////////////////////////////////////
7209 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7210                                                                 Double_t rmax, Int_t nedges, Double_t height){
7211   /////////////////////////////////////////////////////////////
7212   // Method generating Arc shape
7213   /////////////////////////////////////////////////////////////
7214         const Int_t kvertexnumber = 2*nedges+2;
7215         TGeoXtru* arcshape = new TGeoXtru(2);
7216         TVector3** vertexposition[2];
7217         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7218         Double_t angle = 0.;
7219     for(Int_t i=0; i<nedges+1; i++){
7220                 angle = 90.+0.5*phi-i*(phi/nedges);
7221                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7222                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7223         }
7224         Double_t *xvertexpoints = new Double_t[kvertexnumber];
7225         Double_t *yvertexpoints = new Double_t[kvertexnumber];
7226         for(Int_t i=0; i<kvertexnumber; i++){
7227                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7228                                   yvertexpoints[i] = vertexposition[0][i]->Y();
7229                 }
7230                 else if(i>=1&&i<nedges+2)
7231                 {
7232                         xvertexpoints[i] = vertexposition[1][i-1]->X();
7233                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
7234                 }
7235         else
7236                 {
7237                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7238                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7239                 }
7240     }
7241   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7242   arcshape->DefineSection(0,-0.5*height);
7243   arcshape->DefineSection(1,0.5*height);
7244   /////////////////////////////////////////////////////////////
7245   // Deallocating memory
7246   /////////////////////////////////////////////////////////////
7247   for(Int_t i=0; i<2; i++){
7248         for(Int_t j=0; j<nedges+1; j++)
7249                 delete vertexposition[i][j];
7250         delete [] vertexposition[i];
7251   }
7252   delete [] xvertexpoints;
7253   delete [] yvertexpoints;
7254   /////////////////////////////////////////////////////////////
7255         return arcshape;
7256 }
7257 ////////////////////////////////////////////////////////////////////////////////
7258 TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7259   ///////////////////////////////////////////////////////////////////////
7260   // Method Generating the Screw Shape
7261   // radius[0]: outer radius
7262   // radius[1]: inner radius
7263   // edgesnumber[0]: outer number of edges
7264   // edgesnumber[1]: inner number of edges
7265   // section[0]: lower section position
7266   // section[1]: higher section position
7267   ///////////////////////////////////////////////////////////////////////
7268   Double_t outradius = radius[0];
7269   Double_t inradius = radius[1];
7270   Int_t outvertexnumber = edgesnumber[0];
7271   Int_t invertexnumber = edgesnumber[1];
7272   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7273   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7274   for(Int_t i=0; i<outvertexnumber+1; i++){
7275         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7276         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7277   }
7278   for(Int_t i=0; i<invertexnumber+1; i++){
7279         xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7280         yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7281   }
7282   TGeoXtru* screwshape = new TGeoXtru(2);
7283   screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7284   screwshape->DefineSection(0,section[0]);
7285   screwshape->DefineSection(1,section[1]);
7286   delete [] xscrewvertex;
7287   delete [] yscrewvertex;
7288   return screwshape;
7289 }
7290 ////////////////////////////////////////////////////////////////////////////////
7291 TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7292   ///////////////////////////////////////////////////////////////////////
7293   // Method Generating the Hole Shape
7294   // radius of the Hole
7295   // nedges: number of edges to approximate the circle
7296   ///////////////////////////////////////////////////////////////////////
7297   Int_t vertexnumber = nedges+6;
7298   Double_t* xholevertex = new Double_t[vertexnumber];
7299   Double_t* yholevertex = new Double_t[vertexnumber];
7300   xholevertex[0] = radius;
7301   xholevertex[1] = xholevertex[0];
7302   xholevertex[2] = -xholevertex[1];
7303   xholevertex[3] = xholevertex[2];
7304   xholevertex[4] = xholevertex[0];
7305   yholevertex[0] = 0.;
7306   yholevertex[1] = -radius;
7307   yholevertex[2] = yholevertex[1];
7308   yholevertex[3] = -yholevertex[1];
7309   yholevertex[4] = yholevertex[3];
7310   for(Int_t i=0; i<nedges+1; i++){
7311         xholevertex[i+5] = radius*CosD(i*360./nedges);
7312         yholevertex[i+5] = radius*SinD(i*360./nedges);
7313   }
7314   TGeoXtru* holeshape = new TGeoXtru(2);
7315   holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7316   holeshape->DefineSection(0,section[0]);
7317   holeshape->DefineSection(1,section[1]);
7318   delete [] xholevertex;
7319   delete [] yholevertex;
7320   return holeshape;
7321 }
7322 ////////////////////////////////////////////////////////////////////////////////
7323 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7324   /////////////////////////////////////////////////////////////
7325   // Given an axis specified by param, it gives the reflection of the point
7326   // respect to the axis
7327   /////////////////////////////////////////////////////////////
7328   TVector3* n = new TVector3(param[0],param[1],param[2]);
7329   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7330   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
7331   /////////////////////////////////////////////////////////////
7332   // Deallocating memory
7333   /////////////////////////////////////////////////////////////
7334   delete n;
7335   /////////////////////////////////////////////////////////////
7336   return reflectedvector;
7337 }
7338 ////////////////////////////////////////////////////////////////////////////////
7339 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
7340                                                        Double_t dx,
7341                                                        Double_t dy,
7342                                                        Double_t dz) const{
7343   /////////////////////////////////////////////////////////////
7344   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
7345   /////////////////////////////////////////////////////////////
7346   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7347   const Double_t *vect = hmatrix->GetTranslation();
7348   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
7349   hmatrix->SetTranslation(newvect);
7350   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7351   delete hmatrix;
7352   return matrix;
7353 }
7354 ////////////////////////////////////////////////////////////////////////////////
7355 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
7356   /////////////////////////////////////////////////////////////
7357   // Method returning the Medium type
7358   /////////////////////////////////////////////////////////////
7359   char ch[30];
7360   sprintf(ch, "ITS_%s",mediumName);
7361   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
7362   if (! medium)
7363     printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7364   return medium;
7365 }
7366 ////////////////////////////////////////////////////////////////////////////////
7367 void AliITSv11GeometrySSD::CreateMaterials(){
7368 ///////////////////////////////////
7369 // This part has to be modified
7370 ///////////////////////////////////
7371   ///////////////////////////////////
7372   // Silicon for Sensor
7373   ///////////////////////////////////
7374   fSSDSensorMedium = GetMedium("SI$");
7375   ///////////////////////////////////
7376   // Silicon Mixture for Sensor
7377   ///////////////////////////////////
7378   fSSDChipMedium = GetMedium("SPD SI CHIP$");
7379   fSSDChipGlueMedium = GetMedium("EPOXY$");
7380   ///////////////////////////////////
7381   // Stiffener Components Materials
7382   ///////////////////////////////////
7383   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
7384   ///////////////////////////
7385   // Stiffener Connectors
7386   ///////////////////////////
7387   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
7388   ////////////////////////////////
7389   // Stiffener 0603-1812 Capacitor
7390   ////////////////////////////////
7391   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7392   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7393   ///////////////////////////
7394   // Stiffener Hybrid Wire
7395   ///////////////////////////
7396   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
7397   ///////////////////////////
7398   // Al for Cooling Block
7399   ///////////////////////////
7400   fSSDAlCoolBlockMedium = GetMedium("AL$");
7401   //////////////////////////////////////////////////////
7402   // Kapton and Al for Chip Cable Flex and Ladder Cables
7403   //////////////////////////////////////////////////////
7404   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7405   fSSDAlTraceChipCableMedium = GetMedium("AL$");
7406   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7407   fSSDAlTraceFlexMedium = GetMedium("AL$");
7408   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7409   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
7410   /////////////////////////////////////////////////////////////////
7411   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7412   //////////////////////////////////////////////////////////////////
7413   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
7414   /////////////////////////////////////////////////////////////////
7415   // G10 for Detector Leg, TubeHolder
7416   //////////////////////////////////////////////////////////////////
7417   fSSDTubeHolderMedium = GetMedium("G10FR4$");
7418   fSSDSensorSupportMedium = GetMedium("G10FR4$");
7419   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7420   fSSDMountingBlockMedium = GetMedium("G10FR4$");
7421   /////////////////////////////////////////////////////////////////
7422   // Water and Phynox for Cooling Tube
7423   //////////////////////////////////////////////////////////////////
7424   fSSDCoolingTubeWater = GetMedium("WATER$");
7425   fSSDCoolingTubePhynox = GetMedium("INOX$");
7426   /////////////////////////////////////////////////////////////////////
7427   // Material for Support Rings
7428   /////////////////////////////////////////////////////////////////////
7429   fSSDSupportRingAl = GetMedium("AL$");
7430   /////////////////////////////////////////////////////////////////////
7431   fSSDAir = GetMedium("SDD AIR$");
7432   fCreateMaterials = kTRUE;
7433 }
7434 /////////////////////////////////////////////////////////////////////
7435