ITS/AliITSv11GeometrySSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //*************************************************************************
  19 // SSD geometry, based on ROOT geometrical modeler
  20 //
  21 // Enrico Cattaruzza                                    ecattar@ts.infn.it
  22 //*************************************************************************
  23 #include "TMath.h"
  24 #include "TGeoVolume.h"
  25 #include "TGeoMatrix.h"
  26 #include <TGeoManager.h>
  27 #include "TVector3.h"
  28 #include "TGeoArb8.h"
  29 #include "TList.h"
  30 #include "TGeoMatrix.h"
  31 #include "TGeoCompositeShape.h"
  32 #include "TGeoBoolNode.h"
  33 #include "TGeoTube.h"
  34 #include "TGeoBBox.h"
  35 #include "TGeoXtru.h"
  36 #include "TGeoTorus.h"
  37 #include "TGeoPgon.h"
  38 #include "TGeoPcon.h"
  39 #include "TRotation.h"
  40 #include "AliITSv11GeometrySSD.h"
  41
  42 /////////////////////////////////////////////////////////////////////////////////
  43 // Names of the Sensitive Volumes of Layer 5 and Layer 6
  44 /////////////////////////////////////////////////////////////////////////////////
  45 const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
  46 const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6";
  47 /////////////////////////////////////////////////////////////////////////////////
  48 //Parameters for SSD Geometry
  49 /////////////////////////////////////////////////////////////////////////////////
  50 // Variable for Vertical Disalignement of Modules
  51 /////////////////////////////////////////////////////////////////////////////////
  52 const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
  53 const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
  54 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment     = 0.2*fgkmm;
  55 // For ladders:
  56 const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
  57 /////////////////////////////////////////////////////////////////////////////////
  58 // Layer5 (lengths are in mm and angles in degrees)
  59 /////////////////////////////////////////////////////////////////////////////////
  60 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7*fgkmm;
  61 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
  62 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
  63 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0*fgkmm;
  64 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0*fgkmm;
  65 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85*fgkmm;
  66 /////////////////////////////////////////////////////////////////////////////////
  67 // Layer6 (lengths are in mm and angles in degrees)
  68 /////////////////////////////////////////////////////////////////////////////////
  69 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0*fgkmm;
  70 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
  71 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
  72 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0*fgkmm;
  73 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0*fgkmm;
  74 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50*fgkmm;
  75 /////////////////////////////////////////////////////////////////////////////////
  76 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
  77 /////////////////////////////////////////////////////////////////////////////////
  78 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
  79 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm;
  80 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
  81 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
  82 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
  83 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
  84 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
  85 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
  86 /////////////////////////////////////////////////////////////////////////////////
  87 // Stiffener (lengths are in mm and angles in degrees)
  88 /////////////////////////////////////////////////////////////////////////////////
  89 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
  90 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
  91 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.295*fgkmm;
  92 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
  93 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength  =  0.900*fgkmm;  // Includes solder
  94 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm;
  95 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
  96 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
  97 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength  =  0.215*fgkmm;
  98 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
  99 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
 100 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400*fgkmm;
 101 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
 102 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
 103 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32*fgkmm, 0.33*fgkmm};
 104 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =        0.44*fgkmm;
 105 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =        2.16*fgkmm;
 106 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =        3.60*fgkmm;
 107 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       =   0.25*fgkSSDStiffenerHeight;
 108 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =       0.030*fgkmm;
 109 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 110 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight     =   0.15*fgkmm;
 111 /////////////////////////////////////////////////////////////////////////////////
 112 // Cooling Block (lengths are in mm and angles in degrees)
 113 /////////////////////////////////////////////////////////////////////////////////
 114 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 115 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
 116 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
 117                                                                                  {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 118 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
 119   {1.025*fgkmm, 0.120*fgkmm};  // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
 120 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
 121                                                                                                           {1.900*fgkmm, 0.400*fgkmm};
 122 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =
 123                                                                                                                                          1.500*fgkmm;
 124 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 125                                                                                                                                          0.300*fgkmm;
 126 /////////////////////////////////////////////////////////////////////////////////
 127 // SSD Sensor (lengths are in mm and angles in degrees)
 128 /////////////////////////////////////////////////////////////////////////////////
 129 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       =
 130                                                                                                                  "SSDSensorSensitiveVol";
 131 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 132 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 133 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 134 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         =
 135                                                                                                    fgkSSDSensorLength-39.1*fgkmm;
 136 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm;
 137 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 138 /////////////////////////////////////////////////////////////////////////////////
 139 // Flex (lengths are in mm and angles in degrees)
 140 /////////////////////////////////////////////////////////////////////////////////
 141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm;
 142 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        =
 143                         {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 144                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
 145                          0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
 146                                  + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
 147                                                                            - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 148 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         =
 149                                                                                                    {  9.340*fgkmm,  5.380*fgkmm};
 150 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
 151                                                                                                    {  0.030*fgkmm,  0.020*fgkmm};
 152 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 153 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 154 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 155 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
 156                          {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 157 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
 158                                                                                    {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 159 /////////////////////////////////////////////////////////////////////////////////
 160 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 161 /////////////////////////////////////////////////////////////////////////////////
 162 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 163 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = {  0.030*fgkmm*17.5/23.5,  1.25 * 0.030*fgkmm};   // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
 164 /////////////////////////////////////////////////////////////////////////////////
 165 // SSD Module (lengths are in mm and angles in degrees)
 166 /////////////////////////////////////////////////////////////////////////////////
 167 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  =
 168                                                                                                          { 1.000*fgkmm, 3.900*fgkmm};
 169 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
 170                                                                                                                                         45.600*fgkmm;
 171 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 172                                                                                                                                          5.075*fgkmm;
 173 /////////////////////////////////////////////////////////////////////////////////
 174 // Sensor Support (lengths are in mm and angles in degrees)
 175 /////////////////////////////////////////////////////////////////////////////////
 176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                     =
 177                                                                                                                                          5.800*fgkmm;
 178 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =
 179                                                                                                                                          2.000*fgkmm;
 180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 181                                                                                                      { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
 182                                                                                                        5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
 183 //const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
 184 //                                                                                                   { 4.520*fgkmm, 5.130*fgkmm};
 185 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   =
 186                                                                                                          { 0.450*fgkmm, 0.450*fgkmm};
 187 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
 188                                                                 = 0.5 * (fgkSSDModuleSensorSupportDistance
 189                                                             +  fgkSSDSensorSideSupportThickness[0])
 190                                                                 -  fgkSSDSensorSideSupportLength;
 191 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength       =
 192                                                                                                                                     5.250*fgkmm;
 193 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
 194                                                                                                                                         1.680*fgkmm;
 195 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
 196                                                                   = {fgkSSDSensorSideSupportHeight[0]
 197                                                                   +  fgkSSDSensorSideSupportThickness[0],
 198                                                                          fgkSSDSensorSideSupportHeight[1]
 199                                                                   +  fgkSSDSensorSideSupportThickness[1]};
 200 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
 201                                                                   =  {fgkSSDSensorSideSupportThickness[0],
 202                                                                           fgkSSDSensorSideSupportThickness[1]};
 203 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     =
 204                                                                                                                                    19.000*fgkmm;
 205 /////////////////////////////////////////////////////////////////////////////////
 206 // Chip Cables (lengths are in mm and angles in degrees)
 207 /////////////////////////////////////////////////////////////////////////////////
 208 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   =
 209                                   {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 210 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   =
 211                                   {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
 212                                                                   -  (fgkSSDSensorSideSupportHeight[1]
 213                                                                   -   fgkSSDSensorSideSupportHeight[0])
 214                                                                   -   fgkSSDModuleVerticalDisalignment
 215                                                                   -   fgkSSDCoolingBlockHoleCenter
 216                                                                   -   fgkSSDStiffenerHeight
 217                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight,
 218                                                                           fgkSSDModuleCoolingBlockToSensor
 219                                                                   -   fgkSSDModuleVerticalDisalignment
 220                                                                   -   fgkSSDCoolingBlockHoleCenter
 221                                                                   -       fgkSSDStiffenerHeight
 222                                                                   -   fgkSSDChipHeight-fgkSSDSensorHeight};
 223 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    =
 224                                             { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 225 /////////////////////////////////////////////////////////////////////////////////
 226 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 227 /////////////////////////////////////////////////////////////////////////////////
 228 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 229                                                                                                                                         3.820*fgkmm;
 230 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          =
 231 //                                                                                                                                         3.780;
 232 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           =
 233                                                                                  fgkSSDSensorLength-fgkSSDSensorOverlap;
 234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         =
 235                                                                                                         {  0.86*fgkmm,  0.30*fgkmm};
 236 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        =
 237                                                                                                                                 { 30.00, 90.00};
 238 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
 239                                                                                                                                          1.78*fgkmm;
 240 /////////////////////////////////////////////////////////////////////////////////
 241 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
 242 /////////////////////////////////////////////////////////////////////////////////
 243 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
 244                                                                    = fgkSSDModuleSensorSupportDistance
 245                                                                    - 2. * fgkCarbonFiberJunctionToSensorSupport;
 246 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 247 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   =
 248                                                                                                   {  0.751*fgkmm,  0.482*fgkmm};
 249 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  =
 250                                                                                                                                         1.630*fgkmm;
 251 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
 252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
 253                                                                         = fgkCarbonFiberTriangleLength
 254                                                                         - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
 255                                                                         / TMath::Cos(fgkCarbonFiberTriangleAngle
 256                                                                         * TMath::DegToRad());
 257 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
 258                                                                         = 0.5*(fgkCarbonFiberJunctionWidth
 259                                                                         - fgkCarbonFiberSupportWidth)
 260                                                                         - fgkCarbonFiberSupportTopEdgeDist[0]
 261                                                                         - fgkCarbonFiberSupportWidth;
 262 /////////////////////////////////////////////////////////////////////////////////
 263 // Carbon Fiber Lower Support Parameters (lengths are in mm)
 264 /////////////////////////////////////////////////////////////////////////////////
 265 const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ           = 11.575*fgkmm;
 266 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
 267                                                                                                                                           =  0.950*fgkmm;
 268 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
 269                                                                                                                                           =  1.600*fgkmm;
 270 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 271                                                                                                                                           =  0.830*fgkmm;
 272 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
 273                                                                                           = 0.5*fgkCarbonFiberSupportWidth;
 274 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
 275                                                                         = fgkCarbonFiberJunctionWidth
 276                                                                         - 2. * (fgkCarbonFiberLowerSupportWidth
 277                                                                         + fgkCarbonFiberLowerSupportVolumeSeparation);
 278 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
 279                                                                         = {fgkCarbonFiberLowerSupportWidth
 280                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation,
 281                                                                            fgkCarbonFiberLowerSupportWidth
 282                                                                         +  fgkCarbonFiberLowerSupportVolumeSeparation
 283                                                                         +  fgkCarbonFiberLowerSupportTransverseWidth};
 284 /////////////////////////////////////////////////////////////////////////////////
 285 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 286 /////////////////////////////////////////////////////////////////////////////////
 287 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
 288                                                            {0.5 * (fgkSSDLay5LadderLength
 289                                                                         -  fgkSSDLay5SensorsNumber
 290                                                                         *  fgkCarbonFiberJunctionWidth
 291                                                                         -  fgkCarbonFiberLowerSupportWidth),
 292                                                                 0.5 * (fgkSSDLay5LadderLength
 293                                                                         -  fgkSSDLay5SensorsNumber
 294                                                                         *  fgkCarbonFiberJunctionWidth
 295                                                                         +  fgkCarbonFiberLowerSupportWidth)};
 296 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
 297                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
 298                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 299 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
 300                                                 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
 301                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 302 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
 303                                                                                         {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
 304 /////////////////////////////////////////////////////////////////////////////////
 305 // Cooling Tube Support (lengths are in mm and angles in degrees)
 306 /////////////////////////////////////////////////////////////////////////////////
 307 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 308 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
 309                                                                                           = fgkSSDCoolingBlockHoleRadius[0];
 310 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
 311 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
 312 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 313 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    =
 314                                         fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
 315 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
 316                                                                                                                                           11.70*fgkmm;
 317 /////////////////////////////////////////////////////////////////////////////////
 318 // Cooling Tube (lengths are in mm and angles in degrees)
 319 /////////////////////////////////////////////////////////////////////////////////
 320 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
 321 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
 322 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
 323                                                                                                         fgkCarbonFiberJunctionWidth;
 324 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
 325                                                                          fgkSSDModuleSensorSupportDistance
 326                                                                   +      fgkSSDCoolingBlockLength;
 327 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
 328 /////////////////////////////////////////////////////////////////////////////////
 329 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
 330 /////////////////////////////////////////////////////////////////////////////////
 331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            =
 332                                                                                    { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
 334                                                            {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =
 336                                                                                                                                           20.0*fgkmm;
 337 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =
 338                                                                                                                                                     40.0;
 339 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  =
 340                    0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 341 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
 342                                                                                                                                           2.5*fgkmm;
 343 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    =
 344                                                                                                           { 56.0*fgkmm, 12.0*fgkmm};
 345 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     =
 346                                                                                                       {  5.0*fgkmm,  2.9*fgkmm};
 347 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           =
 348                                                                                                                                           1.0*fgkmm;
 349 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =
 350                                                                                                                                           6.0*fgkmm;
 351 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight      =
 352                                                                                                                                           4.0*fgkmm;
 353 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
 354                                                           {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 355 /////////////////////////////////////////////////////////////////////////////////
 356 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
 357 /////////////////////////////////////////////////////////////////////////////////
 358 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength        = 15.1*fgkmm;
 359 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness     = 0.3*fgkmm;
 360 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius   = 1.6*fgkmm;
 361 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
 362 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth         = 9.0*fgkmm;
 363 /////////////////////////////////////////////////////////////////////////////////
 364 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
 365 /////////////////////////////////////////////////////////////////////////////////
 366 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
 367 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight   = 4.0*fgkmm;
 368 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
 369                                                                                                   -  fgkSSDMountingBlockHeight[1]
 370                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 371                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 372                                                                                                   -      fgkMountingBlockSupportDownHeight,
 373                                                                                                          fgkSSDLay6RadiusMin
 374                                                                                                   -  fgkSSDMountingBlockHeight[1]
 375                                                                                                   +  0.5*fgkCoolingTubeSupportHeight
 376                                                                                                   +      fgkSSDModuleCoolingBlockToSensor
 377                                                                                                   -      fgkMountingBlockSupportDownHeight};
 378 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
 379                                                                                                     -  fgkSSDMountingBlockHeight[1]
 380                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 381                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 382                                                                                                         -  fgkMountingBlockSupportRadius[0],
 383                                                                                                            fgkSSDLay6RadiusMax
 384                                                                                                     -  fgkSSDMountingBlockHeight[1]
 385                                                                                                     +  0.5*fgkCoolingTubeSupportHeight
 386                                                                                                     +  fgkSSDModuleCoolingBlockToSensor
 387                                                                                                         -  fgkMountingBlockSupportRadius[1]};
 388 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
 389 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
 390 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
 391 /////////////////////////////////////////////////////////////////////////////////
 392 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
 393 /////////////////////////////////////////////////////////////////////////////////
 394 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
 395 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
 396 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
 397 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
 398                                                                                                 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
 399 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
 400                                   {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
 401 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
 402                                                                                            {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
 403 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
 404 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
 405 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
 406 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
 407 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
 408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
 409 /////////////////////////////////////////////////////////////////////////////////
 410 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
 411 /////////////////////////////////////////////////////////////////////////////////
 412 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
 413 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
 414 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
 415 /////////////////////////////////////////////////////////////////////////////////
 416 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
 417 /////////////////////////////////////////////////////////////////////////////////
 418 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
 419                                                                                                                 {10.5*fgkmm,9.25*fgkmm};
 420 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
 421 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
 422 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
 423                                                                                                         {182.3,177.9,84.4,70.0,35.0};
 424 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
 425                                                                         {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
 426 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
 427 /////////////////////////////////////////////////////////////////////////////////
 428 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
 429 /////////////////////////////////////////////////////////////////////////////////
 430 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
 431                                                                           6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
 432 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
 433                                                                           47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
 434                                                                           20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
 435 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
 436 /////////////////////////////////////////////////////////////////////////////////
 437 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
 438 /////////////////////////////////////////////////////////////////////////////////
 439 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
 440                                                                                                            {62.0*fgkmm,21.87*fgkmm};
 441 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
 442                                                                                                             {47.0*fgkmm,0.35*fgkmm};
 443 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
 444                                                                                                                                           1.0*fgkmm;
 445 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
 446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
 447                                                                                                            {43.5*fgkmm, 0.70*fgkmm};
 448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
 449                                                                                                                                          0.15*fgkmm;
 450 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
 451                                                                                                                                          19.0*fgkmm;
 452 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
 453                                                                                                                  {4.80*fgkmm,1.1*fgkmm};
 454 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
 455                                                                                                                  {3.3*fgkmm,1.10*fgkmm};
 456 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
 457                                                                                                                                           2.1*fgkmm;
 458 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
 459                                                                                                 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
 460 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
 461                                                                                                                  {1.9*fgkmm,0.15*fgkmm};
 462 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
 463                                                                                                                                            19*fgkmm;
 464 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
 465                                                                                                                                           1.0*fgkmm;
 466 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
 467                                                                                                                                           3.6*fgkmm;
 468 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
 469                                                                                                                                          61.0*fgkmm;
 470 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
 471                                                                                                                                          5.97*fgkmm;
 472 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
 473 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
 474                                                                                                 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
 475                                                                           1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
 476 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
 477                                                   {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
 478 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
 479                                                                                                                                           1.0*fgkmm;
 480 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
 481                                                                                                                                    = 0.15*fgkmm;
 482 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
 483                                                                                                                                          20.0*fgkmm;
 484 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
 485 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
 486 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
 487 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
 488 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
 489 /////////////////////////////////////////////////////////////////////////////////
 490 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
 491 /////////////////////////////////////////////////////////////////////////////////
 492 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
 493 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
 494 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
 495 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
 496 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
 497 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 624.9*fgkmm;
 498 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
 499 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
 500 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
 501 /////////////////////////////////////////////////////////////////////////////////
 502 // SSD Cone Parameters (lengths are in mm and angles in degrees)
 503 /////////////////////////////////////////////////////////////////////////////////
 504 const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
 505 const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
 506 const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
 507 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
 508 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
 509 const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
 510 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
 511 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
 512 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
 513 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
 514 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
 515 const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
 516 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
 517 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
 518 const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
 519 const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
 520 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
 521 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
 522 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
 523 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
 524 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
 525 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
 526
 527 /////////////////////////////////////////////////////////////////////////////////
 528 ClassImp(AliITSv11GeometrySSD)
 529 /////////////////////////////////////////////////////////////////////////////////
 530 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
 531   AliITSv11Geometry(),
 532   fSSDChipMedium(),
 533   fSSDChipGlueMedium(),
 534   fSSDStiffenerMedium(),
 535   fSSDStiffenerConnectorMedium(),
 536   fSSDStiffener0603CapacitorMedium(),
 537   fSSDStiffener1812CapacitorMedium(),
 538   fSSDStiffenerCapacitorCapMedium(),
 539   fSSDStiffenerHybridWireMedium(),
 540   fSSDKaptonFlexMedium(),
 541   fSSDAlTraceFlexMedium(),
 542   fSSDAlTraceLadderCableMedium(),
 543   fSSDKaptonLadderCableMedium(),
 544   fSSDKaptonChipCableMedium(),
 545   fSSDAlTraceChipCableMedium(),
 546   fSSDAlCoolBlockMedium(),
 547   fSSDSensorMedium(),
 548   fSSDSensorSupportMedium(),
 549   fSSDCarbonFiberMedium(),
 550   fSSDTubeHolderMedium(),
 551   fSSDCoolingTubeWater(),
 552   fSSDCoolingTubePhynox(),
 553   fSSDSupportRingAl(),
 554   fSSDMountingBlockMedium(),
 555   fSSDRohaCellCone(),
 556   fSSDAir(),
 557   fSSDCopper(),
 558   fSSDSn(),
 559   fCreateMaterials(kFALSE),
 560   fTransformationMatrices(kFALSE),
 561   fBasicObjects(kFALSE),
 562   fcarbonfiberjunction(),
 563   fcoolingtubesupport(),
 564   fhybridmatrix(),
 565   fssdcoolingblocksystem(),
 566   fcoolingblocksystematrix(),
 567   fssdstiffenerflex(),
 568   fssdendflex(),
 569   fcoolingtube(0),
 570   fendladdercoolingtubesupportmatrix(),
 571   fendladdermountingblock(),
 572   fendladdermountingblockclip(),
 573   fSSDSensor5(),
 574   fSSDSensor6(),
 575   fSSDLayer5(),
 576   fSSDLayer6(),
 577   fMotherVol(),
 578   fLay5LadderSupportRing(),
 579   fLay6LadderSupportRing(),
 580   fgkEndCapSupportSystem(),
 581   fSSDCone(),
 582   fColorCarbonFiber(4),
 583   fColorRyton(5),
 584   fColorPhynox(14),
 585   fColorSilicon(3),
 586   fColorAl(38),
 587   fColorNiSn(40),
 588   fColorKapton(6),
 589   fColorPolyhamide(5),
 590   fColorStiffener(9),
 591   fColorEpoxy(30),
 592   fColorWater(7),
 593   fColorG10(41)
 594 {
 595   ////////////////////////
 596   // Standard constructor
 597   ////////////////////////
 598   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
 599     fendladdermountingblockcombitrans[i] = NULL;
 600   }
 601   for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
 602     fcarbonfibersupport[i] = 0;
 603     fcarbonfibersupportmatrix[i] = 0;
 604   }
 605   for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
 606     fcarbonfiberjunctionmatrix[i] = 0;
 607   }
 608   for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
 609     fcarbonfiberlowersupport[i] = 0;
 610     fcarbonfiberlowersupportrans[0] = 0;
 611   }
 612   for (Int_t i=0; i < fgkvolumekind; i++) {
 613     fssdsensorsupport[i] = 0;
 614   }
 615   for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
 616     fssdsensorsupportmatrix[i] = 0;
 617   }
 618   for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
 619     fcoolingtubesupportmatrix[i] = 0;
 620   }
 621   for (Int_t i=0; i < fgkhybridcompnumber; i++) {
 622     fssdhybridcomponent[i] = 0;
 623   }
 624   for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
 625     fcoolingblockmatrix[i] = 0;
 626   }
 627   for (Int_t i=0; i < fgkflexnumber; i++) {
 628     fstiffenerflexmatrix[i] = 0;
 629     fendflexmatrix[i] = 0;
 630   }
 631   for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
 632     fendladdercoolingtube[i] = 0;
 633     for (Int_t j = 0; j < 2; j++)
 634       fendladdercoolingtubematrix[i][j] = 0;
 635   }
 636   for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
 637     fendladdercarbonfiberjunction[i] = 0;
 638   }
 639   for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
 640     fendladdercarbonfiberjunctionmatrix[i] = 0;
 641   }
 642   for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
 643     fendladdercarbonfibermatrix[i] = 0;
 644   }
 645   for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
 646     fendladdermountingblockclipmatrix[i] = 0;
 647   }
 648   for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
 649     fendladderlowersupptrans[i] = 0;
 650   }
 651   for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
 652     fladdercablematrix[i] = 0;
 653   }
 654   for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
 655     fladdersegment[i] = 0;
 656   }
 657   for (Int_t i = 0; i < fgkladdernumber; i++) {
 658     fladder[i] = 0;
 659     fladdermatrix[i] = 0;
 660     fssdsensormatrix[i] = 0;
 661     flayermatrix[i] = 0;
 662   }
 663   for (Int_t i = 0; i < 2; i++) {
 664     fLay5LadderSupport[i] = 0;
 665     fLay6LadderSupport[i] = 0;
 666     fcoolingtubematrix[i] = NULL;
 667     fendladdersegment[i] = NULL;
 668     fendladdersegmentmatrix[i] = NULL;
 669   }
 670 }
 671
 672 ///////////////////////////////////////////////////////////////////////////////
 673 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
 674   ///////////////////////////////////////////////////////////////////////
 675   // Method generating the trasformation matrix for the whole SSD Geometry
 676   ///////////////////////////////////////////////////////////////////////
 677   // Setting some variables for Carbon Fiber Supportmatrix creation
 678   //////////////////////////////////////////////////////////////////////
 679   Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
 680                                                                                    * CosD(fgkCarbonFiberJunctionAngle[0]);
 681   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
 682                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
 683                                                                  +      fgkCarbonFiberSupportWidth);
 684   Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
 685                                                                         * TanD(fgkCarbonFiberJunctionAngle[0]);
 686   TGeoRotation* carbonfiberot[3];
 687   for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
 688   carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
 689   carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
 690   carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
 691   Double_t transvector[3] = {fgkCarbonFiberTriangleLength
 692                                                   *  CosD(fgkCarbonFiberTriangleAngle),0.,
 693                                                   -  fgkCarbonFiberTriangleLength
 694                                                   *      SinD(fgkCarbonFiberTriangleAngle)};
 695   ///////////////////////////////////////////
 696   //Setting Local Translations and Rotations:
 697   ///////////////////////////////////////////
 698   TGeoCombiTrans* localcarbonfibersupportmatrix[3];
 699   localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
 700                                                                          0.5*carbonfibersupportheight,NULL);
 701   localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
 702                                                                          2.*symmetryplaneposition+transvector[1],
 703                                                                          transvector[2], carbonfiberot[2]);
 704   localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
 705   /////////////////////////////////////////////////////////////
 706   // Carbon Fiber Support Transformations
 707   /////////////////////////////////////////////////////////////
 708   const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
 709   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
 710                 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
 711                 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
 712                         fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
 713   }
 714   /////////////////////////////////////////////////////////////
 715   // Carbon Fiber Junction Transformation
 716   /////////////////////////////////////////////////////////////
 717   const Int_t kcarbonfiberjunctionmatrixnumber = 2;
 718   TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
 719   TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
 720   TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
 721   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 722         localcarbonfiberjunctionmatrix[i] =
 723                                                 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
 724         localcarbonfiberjunctionrot[i] =
 725                                                 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
 726         localcarbonfiberjunctiontrans[i] =
 727                                                 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
 728   }
 729   ///////////////////////
 730   // Setting Translations
 731   ///////////////////////
 732   localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
 733   localcarbonfiberjunctiontrans[1][0] =
 734                                  new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
 735   localcarbonfiberjunctiontrans[2][0] =
 736                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 737                                  * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
 738                                  fgkCarbonFiberTriangleLength
 739                                  * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
 740   localcarbonfiberjunctiontrans[0][1] =
 741                                  new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
 742   localcarbonfiberjunctiontrans[1][1] =
 743                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 744   localcarbonfiberjunctiontrans[2][1] =
 745                                  new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
 746   ////////////////////
 747   // Setting Rotations
 748   ////////////////////
 749   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 750                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
 751                         localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
 752   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
 753         localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
 754   localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
 755   localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 756   localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
 757   ////////////////////////////////////////
 758   // Setting Carbon Fiber Junction matrix
 759   ////////////////////////////////////////
 760   for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
 761                 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
 762                 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
 763                         localcarbonfiberjunctionmatrix[i][j] =
 764                         new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
 765                                                            *localcarbonfiberjunctionrot[i][j]);
 766                     fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
 767          }
 768   }
 769   /////////////////////////////////////////////////////////////
 770   // Carbon Fiber Lower Support Transformations
 771   /////////////////////////////////////////////////////////////
 772   TGeoTranslation* localcarbonfiberlowersupportrans[2];
 773   localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
 774                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
 775                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
 776                                                                          0.0);
 777   localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
 778                                                                          fgkCarbonFiberJunctionWidth
 779                                                                 -    fgkCarbonFiberLowerSupportWidth
 780                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[0]
 781                                                                 -    fgkCarbonFiberLowerSupportVolumePosition[1],
 782                                                                 -    0.5*fgkCarbonFiberLowerSupportHeight);
 783    localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
 784    fcarbonfiberlowersupportrans[0] =
 785                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
 786    fcarbonfiberlowersupportrans[1] =
 787                                                 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
 788   /////////////////////////////////////////////////////////////
 789   // SSD Sensor Support Transformations
 790   /////////////////////////////////////////////////////////////
 791   const Int_t kssdsensorsupportmatrixnumber = 3;
 792   TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
 793   TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
 794   TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
 795   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 796         localssdsensorsupportmatrix[i] =
 797                                                 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
 798         localssdsensorsupportrot[i] =
 799                                                 new TGeoRotation*[kssdsensorsupportmatrixnumber];
 800         localssdsensorsupportrans[i] =
 801                                                 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
 802   }
 803   ///////////////////////
 804   // Setting Translations
 805   ///////////////////////
 806   localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
 807                                                                           0.5*fgkSSDSensorSideSupportWidth,
 808                                                                           0.0);
 809   localssdsensorsupportrans[1][0] =
 810                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 811   localssdsensorsupportrans[2][0] =
 812                                                  new TGeoTranslation(*localssdsensorsupportrans[0][0]);
 813   localssdsensorsupportrans[0][1] =
 814                                                  new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
 815                                                                                 0.5*fgkSSDSensorSideSupportThickness[0],
 816                                                                                 0.0);
 817   localssdsensorsupportrans[1][1] =
 818                                                  new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
 819                                                                         -   0.5*fgkSSDSensorSideSupportThickness[0]
 820                                                                     -   fgkSSDModuleSensorSupportDistance,
 821                                                                                 0.0);
 822   localssdsensorsupportrans[2][1] =
 823                                                  new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
 824                                                                         -    fgkSSDSensorCenterSupportPosition,
 825                                                                                  0.5*fgkSSDSensorCenterSupportWidth
 826                                                                         -    0.5*fgkSSDModuleSensorSupportDistance,
 827                                                                                  fgkSSDSensorCenterSupportThickness[0]);
 828   localssdsensorsupportrans[0][2] =
 829                                                  new TGeoTranslation(fgkCarbonFiberTriangleLength
 830                                                                         +    fgkCarbonFiberJunctionToSensorSupport,
 831                                                                                  fgkCarbonFiberJunctionWidth
 832                                                                     -    0.5*(fgkCarbonFiberLowerSupportWidth
 833                                                                         +    fgkSSDSensorCenterSupportLength
 834                                                                         -    fgkSSDSensorCenterSupportThickness[0])
 835                                                                         -    fgkSSDSensorCenterSupportPosition,
 836                                                                              0.0);
 837   localssdsensorsupportrans[1][2] =
 838                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 839   localssdsensorsupportrans[2][2] =
 840                                                 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
 841   ////////////////////
 842   // Setting Rotations
 843   ////////////////////
 844   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
 845                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
 846                         localssdsensorsupportrot[i][j] = new TGeoRotation();
 847   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 848         localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
 849         localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
 850   }
 851   localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
 852   localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
 853   localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
 854   ////////////////////////////////////////
 855   // SSD Sensor Support matrix
 856   ////////////////////////////////////////
 857   for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
 858                 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
 859                 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
 860                         localssdsensorsupportmatrix[i][j] =
 861                         new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
 862                                                            *localssdsensorsupportrot[i][j]);
 863                     fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
 864          }
 865   }
 866   /////////////////////////////////////////////////////////////
 867   // SSD Cooling Tube Support Transformations
 868   /////////////////////////////////////////////////////////////
 869   const Int_t kcoolingtubesupportmatrixnumber = 2;
 870   TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
 871   TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
 872   TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
 873   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
 874                                                                                                         /fgkCoolingTubeSupportRmax);
 875   localcoolingtubesupportrans[0] =
 876                         new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
 877                                                 +  2.*(fgkCoolingTubeSupportLength
 878                                                 -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
 879                                                 +  fgkCarbonFiberTriangleLength
 880                                                 -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
 881   localcoolingtubesupportrans[1] =
 882                         new TGeoTranslation(fgkCarbonFiberJunctionLength
 883                                         - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
 884                                         - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
 885                                                    fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
 886                     +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
 887                     -  0.5*(fgkCarbonFiberLowerSupportWidth
 888                                         +          fgkSSDSensorCenterSupportLength
 889                     -      fgkSSDSensorCenterSupportThickness[0])
 890                                         +  0.5*fgkSSDSensorLength,
 891                                         -  0.5*fgkCoolingTubeSupportHeight);
 892   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 893   localcoolingtubesupportrot[i] = new TGeoRotation();
 894   localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
 895   localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
 896   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
 897         localcoolingtubesupportmatrix[i] =
 898                 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
 899                                                    *localcoolingtubesupportrot[i]);
 900   fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
 901   fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
 902                                                                 (*localcoolingtubesupportmatrix[0]));
 903   /////////////////////////////////////////////////////////////
 904   // End Ladder SSD Cooling Tube Support Transformations
 905   /////////////////////////////////////////////////////////////
 906   TGeoTranslation** localendladdercooltubetrans[2];
 907   localendladdercooltubetrans[0] = new TGeoTranslation*[4];
 908   localendladdercooltubetrans[1] = new TGeoTranslation*[2];
 909   for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
 910   localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
 911                                                                                         -          (fgkCoolingTubeSupportLength
 912                                                                                         -               fgkCoolingTubeSupportRmax),
 913                                                                                                         fgkEndLadderMountingBlockPosition[0]
 914                                                                                         -               fgkendladdercoolingsupportdistance[0]
 915                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 916                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 917   localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
 918                                                                                         -          (fgkCoolingTubeSupportLength
 919                                                                                         -               fgkCoolingTubeSupportRmax),
 920                                                                                                         fgkEndLadderMountingBlockPosition[0]
 921                                                                                         +               fgkendladdercoolingsupportdistance[1]
 922                                                                                         +   0.5*fgkCoolingTubeSupportWidth,
 923                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 924   localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
 925                                                                                         -       fgkCoolingTubeSupportRmax)
 926                                                                                         +               fgkCarbonFiberTriangleLength
 927                                                                                         -   2.0*fgkCarbonFiberJunctionLength,
 928                                                                                                 0.0,
 929                                                                                                 0.0);
 930   localendladdercooltubetrans[0][3]->SetTranslation(0.0,
 931                                                                                                         fgkendladdercoolingsupportdistance[0]
 932                                                                                         +               fgkendladdercoolingsupportdistance[1],
 933                                                                                                         0.0);
 934   for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
 935   localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
 936                                                                                         +               fgkCarbonFiberJunctionLength
 937                                                                                         -               fgkCoolingTubeSupportLength,
 938                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 939                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 940                                                                                                    -fgkendladdercoolingsupportdistance[2],
 941                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 942   localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
 943                                                                                         +               fgkCoolingTubeSupportLength
 944                                                                                         -               fgkCoolingTubeSupportRmax
 945                                                                                         -               fgkCarbonFiberJunctionLength,
 946                                                                                                         fgkEndLadderCarbonFiberLowerJunctionLength[1]
 947                                                                                         -       0.5*fgkCoolingTubeSupportWidth
 948                                                                                         -               fgkendladdercoolingsupportdistance[2],
 949                                                                                         -   0.5*fgkCoolingTubeSupportHeight);
 950   fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
 951   fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
 952   fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
 953   fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
 954   (*localcoolingtubesupportrot[1]));
 955   fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
 956   (*localcoolingtubesupportrot[1]));
 957   fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
 958   fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
 959   fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
 960   fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
 961   fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
 962
 963   fendladdercoolingtubesupportmatrix[1][0] =
 964                                                         new TGeoHMatrix((*localendladdercooltubetrans[1][0])
 965                                                                                    *(*localcoolingtubesupportrot[1]));
 966   fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
 967   fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
 968   fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
 969   /////////////////////////////////////////////////////////////
 970   // SSD Cooling Tube Transformations
 971   /////////////////////////////////////////////////////////////
 972   TGeoRotation* localcoolingtuberot = new TGeoRotation();
 973   localcoolingtuberot->SetAngles(0.,90.,0.);
 974   TGeoTranslation* localcoolingtubetrans[2];
 975   TVector3* localcoolingtubevect[2];
 976
 977   localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
 978                                                   -fgkCarbonFiberTriangleLength),
 979                                             fgkCarbonFiberJunctionWidth         // Y-coord is local Z, from sensor translation
 980                                             - fgkCarbonFiberLowerSupportWidth
 981                                             - fgkLowerSupportToSensorZ ,
 982                                                   -  0.5*fgkCoolingTubeSupportHeight);
 983   localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
 984                                               localcoolingtubevect[0]->Y(),
 985                                               localcoolingtubevect[0]->Z());
 986   for(Int_t j=0; j<2; j++){
 987     localcoolingtubetrans[j] =
 988         new TGeoTranslation(localcoolingtubevect[j]->X(),
 989                             localcoolingtubevect[j]->Y(),
 990                             localcoolingtubevect[j]->Z());
 991      fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
 992                                              *(*localcoolingtuberot));
 993   }
 994   /////////////////////////////////////////////////////////////
 995   // SSD End Ladder Cooling Tube Transformations
 996   /////////////////////////////////////////////////////////////
 997   TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
 998   localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
 999   TGeoTranslation** localendlladdercoolingtubetrans[2];
1000   localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1001   localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
1002   for(Int_t i=0; i<2; i++)
1003         for(Int_t j=0; j<2; j++)
1004                 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1005
1006   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
1007   localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1008                                                                         -        fgkCoolingTubeSupportRmax)
1009                                                                         +        fgkCarbonFiberJunctionLength,
1010                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1011                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1012   localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1013                                                                         -        fgkCoolingTubeSupportRmax)
1014                                                                         -        fgkCarbonFiberJunctionLength
1015                                                                         +    fgkCarbonFiberTriangleLength,
1016                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1017                                                                         - 0.5*fgkCoolingTubeSupportHeight);
1018
1019   localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1020                                                           -   fgkCoolingTubeSupportRmax)
1021                                                         +       fgkCarbonFiberJunctionLength,
1022                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1023                                                   -             0.5*fgkCoolingTubeSupportHeight);
1024   localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1025                                                   -      fgkCoolingTubeSupportRmax)
1026                                                   -      fgkCarbonFiberJunctionLength
1027                                                   +    fgkCarbonFiberTriangleLength,
1028                                                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1029                                                   -             0.5*fgkCoolingTubeSupportHeight);
1030   for(Int_t i=0; i<2; i++)
1031         for(Int_t j=0; j<2; j++){
1032                 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1033                 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1034         }
1035   /////////////////////////////////////////////////////////////
1036   // SSD Hybrid Components Transformations
1037   /////////////////////////////////////////////////////////////
1038   const Int_t khybridmatrixnumber = 3;
1039   TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1040   localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1041                                             0.5*fgkSSDStiffenerWidth,
1042                                             0.5*fgkSSDStiffenerHeight);
1043   localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1044                                             fgkSSDModuleStiffenerPosition[1],0.0);
1045
1046   localhybridtrans[2] = new TGeoTranslation(
1047                       -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1048                       -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1049                               fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1050                       +         0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1051                       -         0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1052                       -       fgkSSDSensorCenterSupportThickness[0]),
1053                       -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1054                       -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
1055                                           -       fgkSSDModuleVerticalDisalignment));
1056   fhybridmatrix = new TGeoHMatrix();
1057   for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1058   /////////////////////////////////////////////////////////////
1059   // SSD Cooling Block Transformations
1060   /////////////////////////////////////////////////////////////
1061   TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1062                                           - 0.5*fgkSSDCoolingBlockLength,
1063                                           fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1064                                           fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1065                                           0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1066   fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
1067   /////////////////////////////////////////////////////////////
1068   // SSD Stiffener Flex Transformations
1069   /////////////////////////////////////////////////////////////
1070   const Int_t klocalflexmatrixnumber = 4;
1071   TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1072   for(Int_t i=0; i<fgkflexnumber; i++)
1073       localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1074   for(Int_t i=0; i<fgkflexnumber; i++)
1075       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1076             localflexmatrix[i][j] = new TGeoCombiTrans();
1077   Double_t ssdstiffenerseparation = fgkSSDSensorLength
1078                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
1079                                                                   -    fgkSSDStiffenerWidth;
1080   localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1081                                         +0.5*fgkSSDStiffenerLength,
1082                                          0.5*fgkSSDStiffenerWidth,
1083                                         -0.5*fgkSSDStiffenerHeight
1084                                         -0.5*fgkSSDFlexHeight[0]);
1085   localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1086                                         +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1087                                         -0.5*fgkSSDStiffenerWidth,
1088                                         -0.5*fgkSSDStiffenerHeight
1089                                         -0.5*fgkSSDFlexHeight[0]);
1090   TGeoRotation* localflexrot = new TGeoRotation();
1091   localflexrot->SetAngles(180.,0.,0.);
1092   localflexmatrix[1][0]->SetRotation(localflexrot);
1093   for(Int_t i=0; i<fgkflexnumber; i++)
1094       for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1095             localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1096   for(Int_t i=0; i<fgkflexnumber; i++){
1097       fstiffenerflexmatrix[i] = new TGeoHMatrix();
1098       for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1099             fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1100   }
1101   /////////////////////////////////////////////////////////////
1102   // SSD End Flex Transformations
1103   /////////////////////////////////////////////////////////////
1104   TGeoRotation* localendflexrot = new TGeoRotation();
1105   localendflexrot->SetAngles(0.0,90.0,0.0);
1106   TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1107   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1108                             /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1109   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1110                             * TMath::DegToRad()*ssdflexradiusmax
1111                                                                - fgkSSDFlexLength[2]-TMath::Pi()
1112                                                                * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1113                                                                                    - 0.1*fgkSSDFlexFullLength;
1114   Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1115                             + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1116                             +      fgkSSDFlexLength[2];
1117   localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1118                               0.5*fgkSSDFlexWidth[0],
1119                               2.*fgkSSDStiffenerHeight
1120                             + 0.5*fgkSSDFlexHeight[0]);
1121   localendflexmatrix->SetRotation(localendflexrot);
1122   for(Int_t i=0; i<fgkflexnumber; i++)
1123       fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1124   /////////////////////////////////////////////////////////////
1125   // End Ladder Carbon Fiber Junction
1126   /////////////////////////////////////////////////////////////
1127   TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1128   TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1129   TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1130   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1131       localendladdercarbonfiberjunctionmatrix[i]
1132             = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
1133       localendladdercarbonfiberjunctionrot[i]
1134             = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1135       localendladdercarbonfiberjunctiontrans[i]
1136             = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1137       fendladdercarbonfiberjunctionmatrix[i]
1138             = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
1139   }
1140   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1141       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1142             localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1143             localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1144       }
1145   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1146       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
1147           localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1148   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149       localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1150                               0.0,0.0);
1151       localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1152                 *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1153                 *                     SinD(fgkCarbonFiberTriangleAngle),
1154                         0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1155   -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1156   }
1157   TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1158   TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1159   TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1160   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161       localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1162       localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1163       localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1164       localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1165             0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1166       localendladdercarbonfiberjunctionglobalmatrix[i] =
1167             new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1168                                *localendladdercarbonfiberjunctionglobalrot[i]);
1169   }
1170   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1172             localendladdercarbonfiberjunctionmatrix[i][j] =
1173                   new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1174                                      *localendladdercarbonfiberjunctionrot[i][j]);
1175            fendladdercarbonfiberjunctionmatrix[i][j] =
1176             new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1177             *               (*localendladdercarbonfiberjunctionmatrix[i][j]));
1178       }
1179   /////////////////////////////////////////////////////////////
1180   // End Ladder Carbon Fiber Support
1181   /////////////////////////////////////////////////////////////
1182   TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1183   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1184       localendladdercarbonfibertrans[i] = new TGeoTranslation();
1185       localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1186             i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1187       fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1188   }
1189   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1190       for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1191             fendladdercarbonfibermatrix[i][j] =
1192             new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1193             *(*fcarbonfibersupportmatrix[j]));
1194   /////////////////////////////////////////////////////////////
1195   // End Ladder SSD Mounting Block
1196   /////////////////////////////////////////////////////////////
1197   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1198       fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1199   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1200       fendladdermountingblockcombitrans[i]->SetTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
1201                                 +        fgkSSDMountingBlockLength[1])
1202                                 +  0.5*fgkCarbonFiberTriangleLength,
1203                                 fgkEndLadderMountingBlockPosition[i],
1204                                 -  fgkSSDMountingBlockHeight[1]
1205                                 +  0.5*fgkSSDMountingBlockHeight[0]);
1206   TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1207   endladdermountingblockrot->SetAngles(0.,90.,0.);
1208   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1209         fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1210   /////////////////////////////////////////////////////////////
1211   // End Ladder SSD Mounting Block Clip Matrix
1212   /////////////////////////////////////////////////////////////
1213   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1214         fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1215
1216   TGeoRotation* localendladdercliprot = new TGeoRotation();
1217   TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1218   localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1219                                                                                   -     fgkSSDMountingBlockLength[1])
1220                                                                                   + fgkSSDMountingBlockLength[0],0.,0.);
1221   localendladdercliprot->SetAngles(90.,180.,-90.);
1222   TGeoCombiTrans* localendladderclipcombitrans =
1223                         new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1224   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1225         for(Int_t j=0; j<2; j++){
1226                 fendladdermountingblockclipmatrix[i][j] =
1227                                                 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1228                 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1229         }
1230   /////////////////////////////////////////////////////////////
1231   // End Ladder Carbon Fiber Lower Support
1232   /////////////////////////////////////////////////////////////
1233   for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1234       fendladderlowersupptrans[i] =
1235             new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1236                         +  0.5*fgkSSDMountingBlockWidth),
1237                         -  0.5*fgkCarbonFiberLowerSupportHeight);
1238   fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
1239   fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1240                                                                          fgkCarbonFiberLowerSupportVolumePosition[1]
1241                                                                 +    fgkCarbonFiberLowerSupportVolumePosition[0],
1242                                                                          0.0);
1243   fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1244  /////////////////////////////////////////////////////////////
1245   // Matrix for positioning Ladder into mother volume
1246   /////////////////////////////////////////////////////////////
1247   TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1248   for(Int_t i=0; i<fgkladdernumber; i++)
1249         ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1250   TGeoRotation* localladdermotherrot = new TGeoRotation();
1251   localladdermotherrot->SetAngles(0.,90.,0.);
1252   TGeoTranslation* localladdermothertrans[fgkladdernumber];
1253   TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1254   for(Int_t i=0; i<fgkladdernumber; i++){
1255         localladdermothertrans[i] = new TGeoTranslation(0.,
1256                                                           - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1257                                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1258                                                           + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1259                                                           * fgkCarbonFiberJunctionWidth,0.);
1260         localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1261                                                                                                                 *localladdermotherrot);
1262         ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1263         ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1264   }
1265   /////////////////////////////////////////////////////////////
1266   // Ladder Cables Matrices
1267   /////////////////////////////////////////////////////////////
1268   Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1269                                              + fgkSSDFlexHeight[1];
1270   Double_t ssdladdercabletransx[3];
1271   ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1272                                                   *   SinD(2.*fgkSSDFlexAngle)
1273                                                   *       CosD(2.*fgkSSDFlexAngle);
1274   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1275                                                   -     ssdladdercabletransx[0]
1276                                                   /     SinD(2.*fgkSSDFlexAngle))
1277                                                   *     CosD(fgkSSDFlexAngle);
1278   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1279                                                   *       TMath::DegToRad()*ssdflexradiusmax
1280                                                   -     fgkSSDFlexLength[2]-TMath::Pi()
1281                                                   *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1282                                                   -       fgkSSDLadderCableWidth)
1283                                                   *       CosD(2.*fgkSSDFlexAngle);
1284   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1285                                                   *     TanD(2.*fgkSSDFlexAngle),
1286                                                         ssdladdercabletransx[1]
1287                                                   *     TanD(fgkSSDFlexAngle),
1288                                                         ssdladdercabletransx[2]
1289                                                   *     TanD(2.*fgkSSDFlexAngle)};
1290   TGeoRotation* localladdercablerot[3];
1291   for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1292   localladdercablerot[0]->SetAngles(90.,0.,0.);
1293   localladdercablerot[1]->SetAngles(90.,60.,-90.);
1294   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1295                                                  *                        (*localladdercablerot[0]));
1296   //TGeoRotation* localladdercablerot = new TGeoRotation();
1297   //localladdercablerot->SetAngles(90.,0.,0.);
1298   ////////////////////////////////////////////
1299   // LocalLadderCableCombiTransMatrix
1300   ////////////////////////////////////////////
1301   const Int_t klocalladdersidecablesnumber = 2;
1302   const Int_t klocalladdercombitransnumber = 5;
1303   TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1304   for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1305          localladdercablecombitransmatrix[i] =
1306                                                            new TGeoCombiTrans*[klocalladdercombitransnumber];
1307   ///////////////////////////////////////////
1308   // Left Side Ladder Cables Transformations
1309   ///////////////////////////////////////////
1310   localladdercablecombitransmatrix[0][0]  =
1311                                                 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1312                                                 0.,0.,NULL);
1313   localladdercablecombitransmatrix[0][1] =
1314         new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1315                                            - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1316                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1317                                            + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1318                                            - 0.5*(fgkCarbonFiberLowerSupportWidth
1319                                            + fgkSSDSensorCenterSupportLength
1320                                            - fgkSSDSensorCenterSupportThickness[0]),
1321                                            - (fgkSSDModuleCoolingBlockToSensor
1322                                            + 0.5*fgkCoolingTubeSupportHeight
1323                                            - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1324                                            - fgkSSDChipHeight),NULL);
1325   localladdercablecombitransmatrix[0][2] =
1326                                                 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1327                                                                                    fgkSSDModuleStiffenerPosition[1],0.,0);
1328   localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1329                                         0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1330                                    +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1331                                    fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1332                                          - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1333                                                                                                 new TGeoRotation("",180.,0.,0.));
1334   localladdercablecombitransmatrix[0][4] =
1335                                                 new TGeoCombiTrans(-ssdladdercabletransx[0]
1336                                                 -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
1337                                                 +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1338                                                           0.,
1339                                                           0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1340                                                 +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1341                                                 +     ssdladdercabletransz[0]-ssdladdercabletransz[1]
1342                                                 +         ssdladdercabletransz[2],localladdercablerot[2]);
1343   ///////////////////////////////////////////
1344   // Rigth Side Ladder Cables Transformations
1345   ///////////////////////////////////////////
1346   TGeoCombiTrans* localladdercablessdmodulematrix =
1347         new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1348                                                                   - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349                                                                          fgkSSDStiffenerWidth,
1350                                                                   - 0.5*fgkSSDFlexHeight[0],NULL);
1351   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1352    localladdercablecombitransmatrix[1][i] =
1353                         (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1354                                         new TGeoCombiTrans(*localladdercablessdmodulematrix));
1355   ///////////////////////////////////////////
1356   // Setting LadderCableHMatrix
1357   ///////////////////////////////////////////
1358   Int_t beamaxistrans[2][3];
1359   beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1360   beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1361   beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1362   beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1363   beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1364   beamaxistrans[1][2] = beamaxistrans[1][0];
1365   TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1366   TGeoRotation* laddercablerot = new TGeoRotation();
1367   TGeoTranslation* laddercabletrans = new TGeoTranslation();
1368   TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1369   Double_t* laddercabletransvector;
1370   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1371         localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1372         fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1373   }
1374   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1375         for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1376                 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1377                 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1378                         localladdercablehmatrix[i][j]->MultiplyLeft(
1379                         localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1380         }
1381                 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1382                 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1383                 laddercabletrans->SetTranslation(laddercabletransvector[0],
1384                                                                          laddercabletransvector[1]
1385                                         +                (j==0 ? beamaxistrans[i][0] : 0.)
1386                                         *                                fgkCarbonFiberJunctionWidth,
1387                                                                          laddercabletransvector[2]);
1388                 laddercablecombitrans->SetRotation(*laddercablerot);
1389                 laddercablecombitrans->SetTranslation(*laddercabletrans);
1390                 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1391         }
1392     fladdercablematrix[i][2] =
1393                                         AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1394                                         beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1395         fladdercablematrix[i][3] =
1396                                         AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1397                                         beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1398   }
1399   for(Int_t i=0; i<fgkladdercablesnumber; i++)
1400     for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1401       fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1402
1403   ///////////////////////////////////////////
1404   // Setting Ladder HMatrix
1405   ///////////////////////////////////////////
1406   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1407                                                                                                 fgkSSDLay6SensorsNumber};
1408   for(Int_t i=0; i<fgkladdernumber; i++){
1409         fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1410         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1411                 fladdermatrix[i][j] = new TGeoHMatrix();
1412                 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1413                 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1414                 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1415         }
1416   }
1417   ///////////////////////////////////////////
1418   // Setting SSD Sensor Matrix
1419   ///////////////////////////////////////////
1420   TGeoCombiTrans* localssdsensorcombitrans[2];
1421   TGeoRotation* localssdsensorrot = new TGeoRotation();
1422   localssdsensorrot->SetAngles(0.,90.,0.);
1423   TGeoTranslation* localssdsensortrans[2];
1424   for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1425   localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1426                                          fgkCarbonFiberJunctionWidth
1427                                          - fgkCarbonFiberLowerSupportWidth
1428                                          - fgkLowerSupportToSensorZ,
1429                                                         0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1430                                           -             fgkSSDModuleCoolingBlockToSensor
1431                                           +    (fgkSSDSensorSideSupportHeight[1]
1432                                           -             fgkSSDSensorSideSupportHeight[0]));
1433   localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1434                                          fgkCarbonFiberJunctionWidth
1435                                          - fgkCarbonFiberLowerSupportWidth
1436                                          - fgkLowerSupportToSensorZ,
1437                                                     0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1438                                                         -fgkSSDModuleCoolingBlockToSensor);
1439
1440   for(Int_t i=0; i<2; i++)
1441         localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1442                                                                                                          *localssdsensorrot);
1443     for(Int_t i=0; i<fgkladdernumber; i++){
1444         fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1445         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1446                 switch(i){
1447                         case 0: //Ladder of Layer5
1448                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1449                                                                    * ((j%2==0 ? *localssdsensorcombitrans[0] :
1450                                                                                                 *localssdsensorcombitrans[1])));
1451                         break;
1452                         case 1: //Ladder of Layer6
1453                         fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1454                                                                    * ((j%2==0 ? *localssdsensorcombitrans[1] :
1455                                                                                                 *localssdsensorcombitrans[0])));
1456                 break;
1457                 }
1458           }
1459   }
1460   //////////////////////////
1461   // Setting SSD End Ladder
1462   //////////////////////////
1463   for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1464   for(Int_t i=0; i<2; i++){
1465         fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1466         fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1467         fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1468         fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1469         fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1470         fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1471         fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1472         fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1473    }
1474   /////////////////////////////////////////////////////
1475   // Setting the CombiTransformation to pass ITS center
1476   /////////////////////////////////////////////////////
1477   Double_t itscentertransz[fgklayernumber];
1478   itscentertransz[0] = fgkSSDLay5LadderLength
1479                                          - fgkLay5CenterITSPosition;
1480   itscentertransz[1] = fgkSSDLay6LadderLength
1481                                          - fgkLay6CenterITSPosition;
1482   Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1483                                                    + 0.5*fgkCoolingTubeSupportHeight;
1484   TGeoRotation* itscenterrot[3];
1485   for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1486   itscenterrot[0]->SetAngles(90.,180.,-90.);
1487   itscenterrot[1]->SetAngles(0.,90.,0.);
1488   itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1489   TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1490   for(Int_t i=0; i<fgklayernumber; i++)
1491         itscentercombitrans[i] = new TGeoCombiTrans(0.,
1492                                                          itssensortransy,
1493                                                          fgkEndLadderCarbonFiberLowerJunctionLength[1]
1494                                                    - itscentertransz[i],itscenterrot[2]);
1495   TGeoRotation** locallayerrot[fgklayernumber];
1496   TGeoTranslation** locallayertrans[fgklayernumber];
1497   TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1498   TGeoTranslation* localbeamaxistrans[fgklayernumber];
1499   localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1500                                          - fgkLay5CenterITSPosition);
1501   localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1502                                          - fgkLay6CenterITSPosition);
1503   const Int_t kssdlayladdernumber[fgklayernumber] =
1504                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1505   for(Int_t i=0; i<fgklayernumber; i++){
1506     locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1507     locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1508         locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1509         flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1510   }
1511   Double_t layerladderangleposition[fgklayernumber] =
1512                 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1513   Double_t layerradius = 0.;
1514   for(Int_t i=0; i<fgklayernumber; i++){
1515         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1516                 switch(i){
1517                         case 0: //Ladder of Layer5
1518                         layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1519                         break;
1520                         case 1: //Ladder of Layer6
1521                         layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1522                 break;
1523                 }
1524                 locallayerrot[i][j] = new TGeoRotation();
1525                 locallayertrans[i][j] = new TGeoTranslation();
1526                 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1527                 locallayertrans[i][j]->SetTranslation(layerradius
1528                                                           *     CosD(90.0+j*layerladderangleposition[i]),
1529                                                             layerradius
1530                                                           * SinD(90.0+j*layerladderangleposition[i]),0.);
1531                 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1532                                                                          *locallayerrot[i][j]);
1533                 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1534                 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1535                 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1536         }
1537   }
1538   /////////////////////////////////////////////////////////////
1539   // Deallocating memory
1540   /////////////////////////////////////////////////////////////
1541   for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1542         delete carbonfiberot[i];
1543         delete localcarbonfibersupportmatrix[i];
1544   }
1545   for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1546      for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1547        delete localcarbonfiberjunctionmatrix[i][j];
1548            delete localcarbonfiberjunctionrot[i][j];
1549            delete localcarbonfiberjunctiontrans[i][j];
1550            }
1551        delete [] localcarbonfiberjunctionmatrix[i];
1552        delete [] localcarbonfiberjunctionrot[i];
1553        delete [] localcarbonfiberjunctiontrans[i];
1554   }
1555   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1556            delete localcarbonfiberlowersupportrans[i];
1557   for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1558      for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1559        delete localssdsensorsupportmatrix[i][j];
1560            delete localssdsensorsupportrot[i][j];
1561            delete localssdsensorsupportrans[i][j];
1562            }
1563        delete [] localssdsensorsupportmatrix[i];
1564        delete [] localssdsensorsupportrot[i];
1565        delete [] localssdsensorsupportrans[i];
1566   }
1567   for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1568         delete localcoolingtubesupportmatrix[i];
1569         delete localcoolingtubesupportrot[i];
1570         delete localcoolingtubesupportrans[i];
1571   }
1572   for(Int_t j=0; j<2; j++){
1573     delete localcoolingtubevect[j];
1574     delete localcoolingtubetrans[j];
1575   }
1576  delete endladdermountingblockrot;
1577  for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1578  for(Int_t i=0; i<fgkflexnumber; i++){
1579       for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1580             delete localflexmatrix[i][j];
1581       delete [] localflexmatrix[i];
1582  }
1583  delete localendlladdercoolingtuberot;
1584  for(Int_t i=0; i<2; i++){
1585         for(Int_t j=0; j<2; j++)
1586           delete localendlladdercoolingtubetrans[i][j];
1587         delete [] localendlladdercoolingtubetrans[i];
1588   }
1589
1590  delete localflexrot;
1591  delete localendflexrot;
1592  delete localendflexmatrix;
1593  for(Int_t i=0; i<fgkladdernumber; i++){
1594         delete localladdermothertrans[i];
1595         delete localladdermothercombitrans[i];
1596   }
1597  delete localladdermotherrot;
1598  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1599       for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1600             delete localendladdercarbonfiberjunctionmatrix[i][j];
1601             delete localendladdercarbonfiberjunctionrot[i][j];
1602             delete localendladdercarbonfiberjunctiontrans[i][j];
1603       }
1604       delete [] localendladdercarbonfiberjunctionmatrix[i];
1605       delete [] localendladdercarbonfiberjunctionrot[i];
1606       delete [] localendladdercarbonfiberjunctiontrans[i];
1607       delete localendladdercarbonfiberjunctionglobalrot[i];
1608       delete localendladdercarbonfiberjunctionglobaltrans[i];
1609       delete localendladdercarbonfiberjunctionglobalmatrix[i];
1610  }
1611   for(Int_t i=0; i<2; i++){
1612         for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1613         delete [] localendladdercooltubetrans[i];
1614   }
1615   for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1616       delete localendladdercarbonfibertrans[i];
1617   for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1618   for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1619         for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1620                 delete localladdercablecombitransmatrix[i][j];
1621                 delete []localladdercablecombitransmatrix[i];
1622   }
1623   delete localendladdercliprot;
1624   delete localendladdercliptrans;
1625   for(Int_t i=0; i<fgkladdercablesnumber; i++){
1626         for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1627                 delete localladdercablehmatrix[i][j];
1628         delete []localladdercablehmatrix[i];
1629   }
1630   delete laddercablerot;
1631   delete laddercabletrans;
1632   delete laddercablecombitrans;
1633   delete localladdercablessdmodulematrix;
1634   delete localssdsensorrot;
1635   for(Int_t i=0; i<2; i++){
1636         delete localssdsensortrans[i];
1637         delete localssdsensorcombitrans[i];
1638   }
1639   for(Int_t i=0; i<fgklayernumber; i++){
1640         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1641                 delete locallayerrot[i][j];
1642                 delete locallayertrans[i][j];
1643                 delete locallayercombitrans[i][j];
1644     }
1645         delete [] locallayerrot[i];
1646         delete [] locallayertrans[i];
1647         delete [] locallayercombitrans[i];
1648         delete localbeamaxistrans[i];
1649   }
1650   for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1651   for(Int_t i=0; i<fgkladdernumber; i++){
1652         for(Int_t j=0; j<fgkladdernumber; j++)
1653                 delete ladderglobalmatrix[i][j];
1654         delete [] ladderglobalmatrix[i];
1655   }
1656   /////////////////////////////////////////////////////////////
1657   fTransformationMatrices = kTRUE;
1658 }
1659 ///////////////////////////////////////////////////////////////////////////////
1660 void AliITSv11GeometrySSD::CreateBasicObjects(){
1661   /////////////////////////////////////////////////////////////
1662   // Method generating the Objects of SSD Geometry
1663   /////////////////////////////////////////////////////////////
1664   // SSD Sensor
1665   ///////////////////////////////////
1666   SetSSDSensor();
1667   /////////////////////////////////////////////////////////////
1668   // Carbon Fiber Support
1669   /////////////////////////////////////////////////////////////
1670   TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1671   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1672       fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1673   /////////////////////////////////////////////////////////////
1674   // Carbon Fiber Junction
1675   /////////////////////////////////////////////////////////////
1676   fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
1677   /////////////////////////////////////////////////////////////
1678   // Carbon Fiber Lower Support
1679   /////////////////////////////////////////////////////////////
1680   TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1681   for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1682         fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1683   /////////////////////////////
1684   // SSD Sensor Support
1685   /////////////////////////////
1686   for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1687                                                                                 new TGeoVolume*[fgkssdsensorsupportnumber];
1688   Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1689                                                                          fgkSSDSensorSideSupportThickness[1]};
1690   for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1691         fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1692                                                                                            fgkSSDSensorSideSupportHeight[i],
1693                                                                                            fgkSSDSensorSideSupportWidth,
1694                                                                                            sidesupporthickness);
1695         fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1696                                                                                            fgkSSDSensorCenterSupportHeight[i],
1697                                                                                            fgkSSDSensorCenterSupportWidth,
1698                                                                                            sidesupporthickness);
1699   }
1700   /////////////////////////////////////////////////////////////
1701   // SSD Cooling Tube Support
1702   /////////////////////////////////////////////////////////////
1703   Int_t edgesnumber = 3;
1704   fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1705   /////////////////////////////////////////////////////////////
1706   // SSD Hybrid
1707   /////////////////////////////////////////////////////////////
1708   TList* ssdhybridcomponentslist = GetSSDHybridParts();
1709   for(Int_t i=0; i<fgkhybridcompnumber; i++)
1710         fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1711   /////////////////////////////////////////////////////////////
1712   // SSD Cooling Block System
1713   /////////////////////////////////////////////////////////////
1714   fssdcoolingblocksystem = GetCoolingBlockSystem();
1715    /////////////////////////////////////////////////////////////
1716   // SSD Cooling Tube
1717   /////////////////////////////////////////////////////////////
1718   CreateCoolingTubes();
1719   /////////////////////////////////////////////////////////////
1720   // SSD Flex
1721   /////////////////////////////////////////////////////////////
1722   fssdstiffenerflex = GetSSDStiffenerFlex();
1723   fssdendflex = GetSSDEndFlex();
1724   ///////////////////////////////////
1725   // End Ladder Carbon Fiber Junction
1726   ///////////////////////////////////
1727   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1728                                                    fendladdercarbonfiberjunction[i] =
1729                                                    new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1730   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1731     fendladdercarbonfiberjunction[i][0] =
1732                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
1733     fendladdercarbonfiberjunction[i][1] =
1734                   GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
1735   }
1736   ///////////////////////////////////
1737   // End Ladder Mounting Block
1738   ///////////////////////////////////
1739   fendladdermountingblock = GetSSDMountingBlock();
1740   ///////////////////////////////////
1741   // End Ladder Mounting Block
1742   ///////////////////////////////////
1743   fendladdermountingblockclip = GetMountingBlockClip();
1744   ///////////////////////////////////
1745   // Ladder Support
1746   ///////////////////////////////////
1747   TList* laddersupportlist = GetMountingBlockSupport(20);
1748   fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1749   fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1750   fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1751   fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1752   /////////////////////////////////////////////////////////////
1753   // Deallocating memory
1754   /////////////////////////////////////////////////////////////
1755   delete carbonfibersupportlist;
1756   delete carbonfiberlowersupportlist;
1757   delete ssdhybridcomponentslist;
1758   delete laddersupportlist;
1759   /////////////////////////////////////////////////////////////
1760   fBasicObjects = kTRUE;
1761 }
1762 /////////////////////////////////////////////////////////////////////////////////
1763 void AliITSv11GeometrySSD::SetSSDSensor(){
1764   ////////////////////////////////////////////////////////////////
1765   // Method generating SSD Sensors: it sets the private variables
1766   // fSSDSensor5, fSSDSensor6
1767   ////////////////////////////////////////////////////////////////
1768   Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1769   Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1770   TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1771                                                 0.5*ssdsensitivewidth,
1772                                                 0.5*fgkSSDSensorHeight,
1773                                                 0.5*ssdsensitivelength);
1774   TGeoVolume* ssdsensorsensitiveLay5 =
1775         new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1776   TGeoVolume* ssdsensorsensitiveLay6 =
1777         new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1778   ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1779   ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1780   TGeoBBox* ssdsensorinsensitiveshape[2];
1781   ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1782                                                 0.5*fgkSSDSensorInsensitiveWidth,
1783                                                 0.5*fgkSSDSensorHeight,
1784                                                 0.5*fgkSSDSensorLength);
1785   ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1786                                                 0.5*ssdsensitivewidth,
1787                                                 0.5*fgkSSDSensorHeight,
1788                                                 0.5*fgkSSDSensorInsensitiveWidth);
1789   const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1790                                              "SSDSensorInsensitive2"};
1791   TGeoVolume* ssdsensorinsensitive[2];
1792   for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1793       new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1794                      fSSDSensorMedium);
1795       ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1796   }
1797   /////////////////////////////////////////////////////////////
1798   // Virtual Volume containing SSD Sensor
1799   /////////////////////////////////////////////////////////////
1800   TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1801                                                                                              0.5*fgkSSDSensorWidth,
1802                                                                                              0.5*fgkSSDSensorHeight,
1803                                                                                              0.5*fgkSSDSensorLength);
1804   fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1805                                                                                  fSSDAir);
1806   fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1807                                                                                  fSSDAir);
1808   /////////////////////////////////////////////////////////////
1809   for(Int_t i=0; i<4; i++){
1810             fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1811             ssdsensorinsensitive[1],i<2?1:2,
1812                         new TGeoTranslation(
1813                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1814       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1815                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1816       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1817             fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1818             ssdsensorinsensitive[1],i<2?1:2,
1819                         new TGeoTranslation(
1820                          0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1821       *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1822                         0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1823       *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1824   }
1825     fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1826     fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1827 }
1828 ///////////////////////////////////////////////////////////////////////////////
1829 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1830   /////////////////////////////////////////////////////////////
1831   // Method generating the Carbon Fiber Support
1832   /////////////////////////////////////////////////////////////
1833   const Int_t kvertexnumber = 4;
1834   const Int_t kshapesnumber = 2;
1835   TVector3** vertexposition[kshapesnumber];
1836   for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1837   Double_t carbonfibersupportxaxisEdgeproj =
1838                 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1839         *       TMath::DegToRad());
1840   Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1841                                  /                         fgkCarbonFiberSupportXAxisLength);
1842   /////////////////////
1843   //Vertex Positioning
1844   ////////////////////
1845   vertexposition[0][0] = new TVector3();
1846   vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1847                                       fgkCarbonFiberSupportYAxisLength, 0);
1848   vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1849                                                                           carbonfibersupportxaxisEdgeproj
1850                                       *                   TMath::Tan(theta), 0);
1851   vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1852                                            -                      carbonfibersupportxaxisEdgeproj,
1853                                                                           fgkCarbonFiberSupportYAxisLength
1854                                       - vertexposition[0][2]->Y(), 0);
1855   ////////////////////////////////////////////////////
1856   //Setting the parameters for Isometry Transformation
1857   ////////////////////////////////////////////////////
1858   Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1859                                                                  +      fgkCarbonFiberSupportTopEdgeDist[0]
1860                                                                  +      fgkCarbonFiberSupportWidth);
1861   Double_t* param = new Double_t[4];
1862   param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1863   for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1864     new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1865                  (GetReflection(vertexposition[0][j],param))->Y(), 0);
1866   const char* carbonfibersupportshapename[kshapesnumber] =
1867                                                 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1868   const char* carbonfibersupportname[kshapesnumber] =
1869                                                 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1870   TGeoArb8* carbonfibersupportshape[kshapesnumber];
1871   TGeoVolume* carbonfibersupport[kshapesnumber];
1872   TList* carbonfibersupportlist = new TList();
1873   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1874   Double_t carbonfibersupportheight =
1875           carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1876           *TMath::DegToRad());
1877   for(Int_t i = 0; i< kshapesnumber; i++){
1878    carbonfibersupportshape[i] =
1879                                         GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1880                                                                 carbonfibersupportshapename[i],i==0 ? 1: -1);
1881    carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1882                                                    carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1883    carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1884    carbonfibersupportlist->Add(carbonfibersupport[i]);
1885    }
1886   /////////////////////////////////////////////////////////////
1887   // Deallocating memory
1888   /////////////////////////////////////////////////////////////
1889   for(Int_t i=0; i< kshapesnumber; i++){
1890      for(Int_t j=0; j< kvertexnumber; j++)
1891            delete vertexposition[i][j];
1892        delete [] vertexposition[i];
1893   }
1894   delete [] param;
1895   /////////////////////////////////////////////////////////////
1896    return carbonfibersupportlist;
1897 }
1898 /////////////////////////////////////////////////////////////////////////////////
1899 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1900   /////////////////////////////////////////////////////////////
1901   // Method generating SSD Carbon Fiber Junction
1902   /////////////////////////////////////////////////////////////
1903   const Int_t kvertexnumber = 6;
1904   TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1905   Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1906                                             *  TMath::DegToRad()),-1.,0.,0.};
1907   TVector3* vertex[kvertexnumber];
1908   vertex[0] = new TVector3();
1909   vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1910                         *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1911                         *                         TMath::DegToRad()),
1912                                                   fgkCarbonFiberJunctionEdge[0]
1913                         *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1914                                         * TMath::DegToRad()), 0);
1915   vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
1916                            fgkCarbonFiberJunctionEdge[1], 0);
1917   vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance, 0, 0);
1918   vertex[1] = GetReflection(vertex[5],reflectionparam);
1919   vertex[2] = GetReflection(vertex[4],reflectionparam);
1920   Double_t xvertexpoints[6], yvertexpoints[6];
1921   for(Int_t i=0; i<kvertexnumber; i++)
1922           xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1923   carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1924   carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1925   carbonfiberjunctionshape->DefineSection(1,0.5*width);
1926   TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1927                                                                 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1928   carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1929   /////////////////////////////////////////////////////////////
1930   // Deallocating memory
1931   /////////////////////////////////////////////////////////////
1932   for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1933   /////////////////////////////////////////////////////////////
1934   return carbonfiberjunction;
1935 }
1936 ////////////////////////////////////////////////////////////////////////////////
1937 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1938   /////////////////////////////////////////////////////////////
1939   // Method generating the Carbon Fiber Lower Support
1940   /////////////////////////////////////////////////////////////
1941   const Int_t kvertexnumber = 4;
1942   const Int_t kshapesnumber = 2;
1943   Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1944                                                                 fgkCarbonFiberLowerSupportWidth};
1945   TVector3** vertexposition[kshapesnumber];
1946   for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1947                                                  new TVector3*[kvertexnumber];
1948   //First Shape Vertex Positioning
1949   vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1950   vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1951                                       - fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1952   vertexposition[0][2] = new TVector3();
1953   vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength, 0, 0);
1954   //Second Shape Vertex Positioning
1955   Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1956                                  -                              fgkCarbonFiberLowerSupportVolumePosition[0])
1957                                  /                              fgkCarbonFiberTriangleLength);
1958   vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1959                                                                 vertexposition[0][0]->X()*TMath::Tan(theta)
1960                                       + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1961   vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1962                                                                 vertexposition[0][1]->X()*TMath::Tan(theta)
1963                                       + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1964   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1965   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1966                                       fgkCarbonFiberLowerSupportVolumePosition[1], 0);
1967   const char* carbonfiberlowersupportshapename[kshapesnumber] =
1968                           {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
1969   const char* carbonfiberlowersupportname[kshapesnumber] =
1970                           {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1971   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1972   TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1973   TList* carbonfiberlowersupportlist = new TList();
1974   for(Int_t i = 0; i< kshapesnumber; i++){
1975         carbonfiberlowersupportshape[i] =
1976                                                                 GetArbShape(vertexposition[i],width,
1977                                                                                         fgkCarbonFiberLowerSupportHeight,
1978                                                                                         carbonfiberlowersupportshapename[i]);
1979     carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1980                                                 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1981         carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
1982     carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
1983   }
1984   /////////////////////////////////////////////////////////////
1985   // Deallocating memory
1986   /////////////////////////////////////////////////////////////
1987   for(Int_t i=0; i< kshapesnumber; i++){
1988      for(Int_t j=0; j< kvertexnumber; j++)
1989            delete vertexposition[i][j];
1990        delete [] vertexposition[i];
1991   }
1992   /////////////////////////////////////////////////////////////
1993   return carbonfiberlowersupportlist;
1994 }
1995 ///////////////////////////////////////////////////////////////////////////////
1996 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
1997                                                                  Double_t width, const Double_t* thickness)const{
1998   /////////////////////////////////////////////////////////////
1999   // Method generating the Sensor Support
2000   /////////////////////////////////////////////////////////////
2001         const Int_t kvertexnumber = 6;
2002         TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2003     TVector3* vertexposition[kvertexnumber];
2004         vertexposition[0] = new TVector3();
2005         vertexposition[1] = new TVector3(0.0,length,0);
2006         vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y(),0);
2007         vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0],0);
2008         vertexposition[4] = new TVector3(height,vertexposition[3]->Y(),0);
2009         vertexposition[5] = new TVector3(vertexposition[4]->X(),0,0);
2010         Double_t xvertexpoints[6], yvertexpoints[6];
2011         for(Int_t i=0; i<kvertexnumber; i++)
2012                 xvertexpoints[i] = vertexposition[i]->X(),
2013                 yvertexpoints[i] = vertexposition[i]->Y();
2014     ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2015     ssdsensorsupportshape->DefineSection(0,-0.5*width);
2016     ssdsensorsupportshape->DefineSection(1,0.5*width);
2017     TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2018                                                                  ssdsensorsupportshape,fSSDSensorSupportMedium);
2019   /////////////////////////////////////////////////////////////
2020   // Deallocating memory
2021   /////////////////////////////////////////////////////////////
2022         for (Int_t i=0; i<kvertexnumber; i++)
2023                 delete vertexposition[i];
2024   /////////////////////////////////////////////////////////////
2025     return ssdsensorsupport;
2026 }
2027 ////////////////////////////////////////////////////////////////////////////////
2028 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2029   /////////////////////////////////////////////////////////////
2030   // Method generating the Cooling Tube Support
2031   /////////////////////////////////////////////////////////////
2032   if(nedges%2!=0) nedges--;
2033   const Int_t kvertexnumber = nedges+5;
2034   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2035                            /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2036   Double_t angle = 90.+phi;
2037   Double_t psi = 90.-phi;
2038   ///////////////////////////////////////
2039   // Vertex Positioning for TGeoXTru
2040   ///////////////////////////////////////
2041   TVector3** vertexposition = new TVector3*[kvertexnumber];
2042
2043   Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges);  //  Recalc inner radius so that tube fits inside
2044   vertexposition[0] = new TVector3(router*CosD(angle),
2045                                    router*SinD(angle), 0);
2046   vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2047                                    fgkCoolingTubeSupportRmax*SinD(angle),0);
2048   vertexposition[2] = new TVector3(vertexposition[1]->X(),
2049                                    fgkCoolingTubeSupportRmax, 0);
2050   vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2051                                    fgkCoolingTubeSupportRmax, 0);
2052   vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2053                                    vertexposition[1]->Y(), 0);
2054
2055   for(Int_t i=0; i<nedges; i++)
2056         vertexposition[i+5] =
2057                 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
2058                              router*SinD(psi+i*(2.*phi/nedges)), 0);
2059   ///////////////////////////////////////////////////////////////////////
2060   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2061   ///////////////////////////////////////////////////////////////////////
2062   TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2063   Double_t* xvertexpoints = new Double_t[kvertexnumber];
2064   Double_t* yvertexpoints = new Double_t[kvertexnumber];
2065   for(Int_t i=0; i<kvertexnumber; i++){
2066         xvertexpoints[i] = vertexposition[i]->X();
2067         yvertexpoints[i] = vertexposition[i]->Y();
2068   }
2069   coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2070                                                                                         yvertexpoints);
2071   coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2072   coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2073   TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2074                                                                           coolingtubesupportarcshape,
2075                                                                                   fSSDTubeHolderMedium);
2076   coolingtubesupportarc->SetLineColor(fColorG10);
2077   //////////////////////////////////////////////////////////////////////////
2078   // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2079   //////////////////////////////////////////////////////////////////////////
2080   TGeoTubeSeg* coolingtubesupportsegshape =
2081                                                         new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2082                                                                                         fgkCoolingTubeSupportRmax,
2083                                                                                         0.5*fgkCoolingTubeSupportWidth,
2084                                                                                         phi,360-phi);
2085   TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2086                                                                                         coolingtubesupportsegshape,
2087                                                                                         fSSDTubeHolderMedium);
2088   coolingtubesupportseg->SetLineColor(fColorG10);
2089   //////////////////////////////////////////////////////////////////////////
2090   // TGeoBBox Volume definition for Cooling Tube Support Box Part
2091   //////////////////////////////////////////////////////////////////////////
2092   Double_t* boxorigin = new Double_t[3];
2093   Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2094   boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2095   TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2096                                                                                  0.5*fgkCoolingTubeSupportHeight,
2097                                                                                  0.5*fgkCoolingTubeSupportWidth,boxorigin);
2098   TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2099                                coolingtubesupportboxshape,fSSDTubeHolderMedium);
2100   coolingtubesupportbox->SetLineColor(fColorG10);
2101   //////////////////////////////////////////////////////////////////////////
2102   // Cooling Tube for Cooling Tube Support
2103   //////////////////////////////////////////////////////////////////////////
2104   TGeoXtru* coolingtubearcshape[2];
2105   coolingtubearcshape[0] = new TGeoXtru(2);
2106   Double_t* xvert = new Double_t[nedges+2];
2107   Double_t* yvert = new Double_t[nedges+2];
2108   Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2109   ////////////////////////////////////////
2110   // Positioning the vertices for TGeoXTru
2111   ////////////////////////////////////////
2112   xvert[0] = 0., yvert[0] = 0.;
2113   xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
2114   for(Int_t i=0; i< nedges; i++)
2115                 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2116                 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2117   ////////////////////////////////////////
2118   // Defining TGeoXTru PolyGone
2119   ////////////////////////////////////////
2120   coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2121   coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2122   coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2123   coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2124                 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2125   TGeoVolume* coolingtubearc[2];
2126   coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2127                                                                   coolingtubearcshape[0],fSSDCoolingTubeWater);
2128   coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2129                                                                   coolingtubearcshape[1],fSSDCoolingTubePhynox);
2130   coolingtubearc[0]->SetLineColor(fColorWater);
2131   coolingtubearc[1]->SetLineColor(fColorPhynox);
2132   ////////////////////////////////////////////
2133   // Defining TGeoTubeSeg Part of Cooling Tube
2134   ////////////////////////////////////////////
2135   TGeoTubeSeg* coolingtubesegshape[2];
2136   coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2137                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2138   coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2139                                                         0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2140   TGeoVolume* coolingtubeseg[2];
2141   coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2142                                                                  coolingtubesegshape[0],fSSDCoolingTubePhynox);
2143   coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2144                                                                  coolingtubesegshape[1],fSSDCoolingTubeWater);
2145   coolingtubeseg[0]->SetLineColor(fColorPhynox);
2146   coolingtubeseg[1]->SetLineColor(fColorWater);
2147   /////////////////////////////////////////////////////////////
2148   // Virtual Volume containing Cooling Tube Support
2149   /////////////////////////////////////////////////////////////
2150   TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2151   const Int_t kvirtualvertexnumber = 8;
2152   TVector3* virtualvertex[kvirtualvertexnumber];
2153    ////////////////////////////////////////
2154   // Positioning the vertices for TGeoXTru
2155   ////////////////////////////////////////
2156   virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax, 0);
2157   virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y(),0);
2158   virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y(),0);
2159   virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight,0);
2160   virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y(),0);
2161   virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y(),0);
2162   virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y(),0);
2163   virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y(),0);
2164   Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2165   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2166         xmothervertex[i] = virtualvertex[i]->X(),
2167         ymothervertex[i] = virtualvertex[i]->Y();
2168   ////////////////////////////////////////
2169   // Defining TGeoXTru PolyGone
2170   ////////////////////////////////////////
2171   virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2172                                                                                                                                          ymothervertex);
2173   virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2174   virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2175   /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2176     virtualCoolingTubeSupportShape,fSSDAir); */
2177   TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2178
2179   ////////////////////////////////////////
2180   // Positioning Volumes in Virtual Volume
2181   ////////////////////////////////////////
2182   TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2183   coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2184   virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2185   virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2186   virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2187   //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2188   //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2189   //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2190   //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2191   /////////////////////////////////////////////////////////////
2192   // Deallocating memory
2193   /////////////////////////////////////////////////////////////
2194   delete [] vertexposition;
2195   delete [] xvertexpoints;
2196   delete [] yvertexpoints;
2197   delete [] xvert;
2198   delete [] yvert;
2199   for(Int_t i=0; i< kvirtualvertexnumber; i++)
2200         delete virtualvertex[i];
2201   /////////////////////////////////////////////////////////////
2202         return virtualcoolingtubesupport;
2203 }
2204 /////////////////////////////////////////////////////////////////////////////////
2205 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2206   /////////////////////////////////////////////////////////////
2207   // Method generating List containing SSD Hybrid Components
2208   /////////////////////////////////////////////////////////////
2209   TList* ssdhybridlist = new TList();
2210   const Int_t kssdstiffenernumber = 2;
2211   Double_t ssdstiffenerseparation = fgkSSDSensorLength
2212                                                                   - 2.*fgkSSDModuleStiffenerPosition[1]
2213                                                                   -    fgkSSDStiffenerWidth;
2214   Double_t ssdchipcablesradius[kssdstiffenernumber];
2215   for(Int_t i=0; i<kssdstiffenernumber; i++)
2216           ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2217                                -  fgkSSDChipCablesHeight[0]
2218                                -  fgkSSDChipCablesHeight[1]);
2219   /////////////////////////////////////////////////////////////
2220   // Mother Volumes Containers
2221   /////////////////////////////////////////////////////////////
2222   const Int_t kmothernumber = 2;
2223   const Int_t kmothervertexnumber = 8;
2224   Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2225   Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2226
2227   TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2228   TGeoVolume* ssdhybridmother[kmothernumber][2];
2229
2230   TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2231   TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2232   TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2233
2234   const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2235   for(Int_t i=0; i<kmothernumber; i++){
2236     xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2237     ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2238     xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2239     ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2240       -fgkSSDChipCablesHeight[i+2];
2241
2242     xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2243     ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2244     xmothervertex[i][3] = xmothervertex[i][2];
2245     ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
2246
2247     xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2248     ymothervertex[i][4] = ymothervertex[i][3];
2249     xmothervertex[i][5] = xmothervertex[i][4];
2250     ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
2251
2252     xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2253     ymothervertex[i][6] = ymothervertex[i][5];
2254
2255     xmothervertex[i][7] = xmothervertex[i][6];
2256     ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2257     TGeoXtru *shape = new TGeoXtru(2);
2258     shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2259     shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2260     shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2261     ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2262     ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2263     ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
2264    }
2265   /////////////////////////////////////////////////////////////
2266   // SSD Stiffener
2267   /////////////////////////////////////////////////////////////
2268   TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2269                                              0.5*fgkSSDStiffenerLength,
2270                                              0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
2271                                              0.5*fgkSSDStiffenerHeight);
2272   TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2273                                             fSSDStiffenerMedium);
2274   ssdstiffener->SetLineColor(fColorStiffener);
2275
2276 ////////////////////////////
2277 // Capacitor 0603-2200 nF
2278 ///////////////////////////
2279   const Int_t knapacitor0603number = 5;
2280   TGeoBBox* capacitor0603mothershape =  new TGeoBBox("Capacitor0603MotherShape",
2281                                                0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2282                                                0.5*fgkSSDCapacitor0603Width,
2283                                                0.5*fgkSSDCapacitor0603Height);
2284   TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2285                                              fSSDAir);
2286
2287   TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
2288                                                0.5*fgkSSDCapacitor0603Length,
2289                                                0.5*fgkSSDCapacitor0603Width,
2290                                                0.5*fgkSSDCapacitor0603Height);
2291   TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2292                                              fSSDStiffener0603CapacitorMedium);
2293   capacitor0603->SetLineColor(fColorAl);
2294   TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2295   capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2296
2297   TGeoBBox* capacitor0603capshape =  new TGeoBBox("Capacitor0603CapShape",
2298                                                0.5*fgkSSDCapacitor0603CapLength,
2299                                                0.5*fgkSSDCapacitor0603Width,
2300                                                0.5*fgkSSDCapacitor0603Height);
2301   TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2302                                              fSSDStiffenerCapacitorCapMedium);
2303   capacitor0603cap->SetLineColor(fColorNiSn);
2304   TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2305   capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2306   TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2307   capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2308
2309
2310   TGeoVolume* ssdchip = GetSSDChip();
2311
2312   const Int_t knedges = 5;
2313   TGeoVolume *ssdchipcables[2];
2314
2315   for(Int_t i=0; i<kmothernumber; i++){
2316     for(Int_t j=0; j<kssdstiffenernumber; j++){
2317       ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2318       for(Int_t k=1; k<knapacitor0603number+1; k++){
2319         ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
2320                                        new TGeoCombiTrans("",
2321                                                           -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2322                                                           -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2323                                                           (k-3.)/6*fgkSSDStiffenerLength,
2324                                                           hybridmotherrotInv));
2325       }
2326     }
2327
2328     GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2329     for(Int_t k=0; k<fgkSSDChipNumber; k++){
2330       TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2331                                                             - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2332                                                             - fgkSSDChipCablesHeight[i+2],
2333                                                             (k+0.5-fgkSSDChipNumber/2)*
2334                                                             (fgkSSDChipLength + fgkSSDChipSeparationLength));
2335       TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2336                                                      - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2337                                                      (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2338                                                      hybridmotherrotInv);
2339       for(Int_t j=0; j<kssdstiffenernumber; j++){
2340         ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2341         ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2342       }
2343     }
2344     // Final placement by assembly
2345     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2346     ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2347     ssdhybridlist->Add(ssdhybridassembly[i]);
2348   }
2349   /////////////////////////////////////////////////////////////
2350   // Mother Volume Containing Capacitor Part
2351   /////////////////////////////////////////////////////////////
2352   const Int_t kcapacitormothernumber = 8;
2353   Double_t xcapacitorvertex[kcapacitormothernumber];
2354   Double_t ycapacitorvertex[kcapacitormothernumber];
2355   ///////////////////////
2356   // Setting the vertices
2357   ///////////////////////
2358   xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2359   xcapacitorvertex[1] = xcapacitorvertex[0];
2360   xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2361   xcapacitorvertex[3] = xcapacitorvertex[2];
2362   xcapacitorvertex[4] = xcapacitorvertex[0];
2363   xcapacitorvertex[5] = xcapacitorvertex[0];
2364   xcapacitorvertex[6] = -xcapacitorvertex[0];
2365   xcapacitorvertex[7] = xcapacitorvertex[6];
2366   ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2367   ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2368   ycapacitorvertex[2] = ycapacitorvertex[1];
2369   ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2370   ycapacitorvertex[4] = ycapacitorvertex[3];
2371   ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2372   ycapacitorvertex[6] = ycapacitorvertex[5];
2373   ycapacitorvertex[7] = ycapacitorvertex[0];
2374   TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2375   ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2376                                               ycapacitorvertex);
2377   ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2378   ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2379 //  TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2380 //                                          fSSDAir);
2381   TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
2382 ////////////////////////////
2383 // Connector
2384 ///////////////////////////
2385   const Int_t kssdconnectorlayernumber = 3;
2386   TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2387   Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2388   /*
2389   Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2390   Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2391                                    +  fgkSSDConnectorAlHeight};
2392   */
2393   Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2394   const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2395   TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2396   TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2397   for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2398     ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2399       ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2400                                           0.5*fgkSSDConnectorWidth,
2401                                           0.5*ssdConnectorThickness[i],
2402                                           ssdconnectororigin);
2403       ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2404       ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2405                                        ssdConnectorMedium[i]);
2406       ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
2407   }
2408   const Int_t kssdconnectornumber = 4;
2409   TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
2410   ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2411                        +  fgkSSDConnectorPosition[0]
2412                        -  fgkSSDConnectorSeparation
2413                        -  1.5*fgkSSDConnectorLength,
2414                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2415                        -  fgkSSDConnectorPosition[1]
2416                        -  ssdconnectorshape[0]->GetDY(),0.0);
2417   ssdconnectortrans[1] = new TGeoTranslation(
2418                        -  ssdstiffenershape->GetDX()
2419                        +  fgkSSDConnectorPosition[0]
2420                        -  0.5*fgkSSDConnectorLength,
2421                           ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422                        -  fgkSSDConnectorPosition[1]
2423                        -  ssdconnectorshape[0]->GetDY(),0.0);
2424   ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2425                        -  fgkSSDConnectorPosition[0]
2426                        +  fgkSSDConnectorSeparation
2427                        +  1.5*fgkSSDConnectorLength,
2428                           -(ssdstiffenershape->GetDY()
2429                        -  fgkSSDConnectorPosition[1]
2430                        -  ssdconnectorshape[0]->GetDY()),0.0);
2431   ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432                        -  fgkSSDConnectorPosition[0]
2433                        +  0.5*fgkSSDConnectorLength,
2434                           -(ssdstiffenershape->GetDY()
2435                        -  fgkSSDConnectorPosition[1]
2436                        -  ssdconnectorshape[0]->GetDY()),0.0);
2437   for(Int_t i=0; i<kssdconnectornumber; i++) {
2438     Int_t nlay = kssdconnectorlayernumber - 1;
2439     if (i == 1 || i == 2)
2440       nlay++;
2441     for(Int_t j=0; j<nlay; j++)
2442       ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2443   }
2444 ////////////////////////////
2445 // Capacitor 1812-330 nF
2446 ///////////////////////////
2447 //  Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2448   TGeoBBox* capacitor1812shape =  new TGeoBBox("Capacitor1812Shape",
2449                                                                                          0.5*fgkSSDCapacitor1812Length,
2450                                                                                          0.5*fgkSSDCapacitor1812Width,
2451                                                0.5*fgkSSDCapacitor1812Height);
2452   //            ssdcapacitor1812origin);
2453   TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2454                                              fSSDStiffener1812CapacitorMedium);
2455   capacitor1812->SetLineColor(fColorAl);
2456   TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2457                                         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2458                                       - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2459   ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2460
2461   TGeoBBox* capacitor1812capshape =  new TGeoBBox("Capacitor1812CapShape",
2462     0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2463     0.5*fgkSSDCapacitor1812Height);
2464   TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2465                                              fSSDStiffenerCapacitorCapMedium);
2466   capacitor1812cap->SetLineColor(fColorNiSn);
2467   TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2468         - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2469         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2470         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2471         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2472   ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2473   TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2474         capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2475         0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2476         - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2477         0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2478   ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2479
2480 ////////////////////////////
2481 //Hybrid Wire
2482 ////////////////////////////
2483   Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2484                                  - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2485                                  - fgkSSDConnectorSeparation;
2486   Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2487                                  - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2488   Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2489
2490   Double_t wireangle = TMath::ATan(wirex/wirey);
2491   TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2492                                                 fgkSSDWireRadius, 0.5*ssdwireradius);
2493   TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2494                                              fSSDStiffenerHybridWireMedium);
2495   hybridwire->SetLineColor(fColorPhynox);
2496   TGeoCombiTrans* hybridwirecombitrans[2];
2497   hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2498                    0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2499                                  + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2500                    0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2501                                  + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2502                                    ssdstiffenershape->GetDZ()
2503                                  + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
2504                    new TGeoRotation("HybridWireRot1",0.,90.,0.));
2505   hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2506                             0.0,
2507                           - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2508                             0.0,
2509                             new TGeoRotation("HybridWireRot2",
2510                           - wireangle*TMath::RadToDeg(),0.,0.));
2511   TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2512   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2513   hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2514   ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2515   ssdhybridlist->Add(ssdhybridcapacitormother);
2516   /////////////////////////////////////////////////////////////
2517   // Deallocating memory
2518   /////////////////////////////////////////////////////////////
2519   delete hybridwirecombitrans[0];
2520   delete hybridwirecombitrans[1];
2521   return ssdhybridlist;
2522   /////////////////////////////////////////////////////////////
2523 }
2524 ///////////////////////////////////////////////////////////////////////////////
2525 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2526   /////////////////////////////////////////////////////////////
2527   // SSD Cooling Block System
2528   /////////////////////////////////////////////////////////////
2529   // SSD Cooling Block and Cooling Tube Transformations
2530   /////////////////////////////////////////////////////////////
2531   TGeoRotation* localcoolingblockrot = new TGeoRotation();
2532   localcoolingblockrot->SetAngles(0.,90.,0.);
2533   TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2534   TVector3* coolingblocktransvector;
2535   coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
2536                                                                   fgkSSDSensorLength
2537                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
2538                                          - fgkSSDCoolingBlockWidth, 0);
2539   const Int_t kcoolingblocktransnumber = 2;
2540   const Int_t kcoolingblocknumber = 4;
2541   TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2542   TGeoRotation* localcoolingtuberot = new TGeoRotation();
2543   localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2544   for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2545     for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2546       TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
2547                                              j*coolingblocktransvector->Y(),
2548                                              - 0.5*(fgkSSDCoolingBlockHoleCenter
2549                                                     + fgkCoolingTubeRmax));
2550       coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2551     }
2552   }
2553   TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2554   TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2555   /////////////////////////////////////////////////////////////
2556   // Adding Cooling block to mother volume
2557   /////////////////////////////////////////////////////////////
2558   for(Int_t i=0; i<kcoolingblocknumber; i++){
2559     coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2560   }
2561   /////////////////////////////////////////////////////////////
2562   // Deallocating memory
2563   /////////////////////////////////////////////////////////////
2564   delete coolingblocktransvector;
2565   delete localcoolingblockrot;
2566
2567   return coolingsystemother;
2568 }
2569 /////////////////////////////////////////////////////////////////////////////////
2570 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2571   /////////////////////////////////////////////////////////////
2572   // SSD Flex
2573   /////////////////////////////////////////////////////////////
2574   const Int_t kssdflexlayernumber = 2;
2575   TGeoXtru* ssdflexshape[kssdflexlayernumber];
2576   for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2577   const Int_t kmothervertexnumber = 17;
2578   Double_t xmothervertex[kmothervertexnumber];
2579   Double_t ymothervertex[kmothervertexnumber];
2580   /////////////////////////////////////////////
2581   // Auxiliary variables for vertex positioning
2582   /////////////////////////////////////////////
2583   const Int_t kssdflexboxnumber = 5;
2584   Double_t ssdflexboxlength[kssdflexboxnumber];
2585   ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2586                                           *     fgkSSDChipLength+(fgkSSDChipNumber-1)
2587                                           *     fgkSSDChipSeparationLength
2588                                           - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2589                                           - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2590   ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2591   ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2592                                           -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2593   ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2594   ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2595                                           -     ssdflexboxlength[1];
2596   Double_t ssdflexboxwidth[kssdflexboxnumber];
2597   ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2598   ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2599   ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2600   ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2601   ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2602   ///////////////////////
2603   // Setting the vertices
2604   ///////////////////////
2605   xmothervertex[0]  = 0.0;
2606   xmothervertex[1]  = xmothervertex[0];
2607   xmothervertex[2]  = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2608   xmothervertex[3]  = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2609                                         + ssdflexboxlength[4];
2610   xmothervertex[4]  = xmothervertex[3];
2611   xmothervertex[5]  = xmothervertex[4]-ssdflexboxlength[4];
2612   xmothervertex[6]  = xmothervertex[5];
2613   xmothervertex[7]  = xmothervertex[6]-fgkSSDFlexHoleLength;
2614   xmothervertex[8]  = xmothervertex[7];
2615   xmothervertex[9]  = xmothervertex[8]-ssdflexboxlength[2];
2616   xmothervertex[10] = xmothervertex[9];
2617   xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2618   xmothervertex[12] = xmothervertex[11];
2619   xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2620   xmothervertex[14] = xmothervertex[13];
2621   xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2622   xmothervertex[16] = xmothervertex[15];
2623   ymothervertex[0]  = 0.0;
2624   ymothervertex[1]  = fgkSSDFlexWidth[1];
2625   ymothervertex[2]  = fgkSSDFlexWidth[0];
2626   ymothervertex[3]  = ymothervertex[2];
2627   ymothervertex[4]  = ymothervertex[0];
2628   ymothervertex[5]  = ymothervertex[4];
2629   ymothervertex[6]  = ssdflexboxwidth[2];
2630   ymothervertex[7]  = ymothervertex[6];
2631   ymothervertex[8]  = ymothervertex[0];
2632   ymothervertex[9]  = ymothervertex[8];
2633   ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2634   ymothervertex[11] = ymothervertex[10];
2635   ymothervertex[12] = ymothervertex[0];
2636   ymothervertex[13] = ymothervertex[12];
2637   ymothervertex[14] = ymothervertex[7];
2638   ymothervertex[15] = ymothervertex[14];
2639   ymothervertex[16] = ymothervertex[0];
2640   /////////////////////////////////////////////////////////////
2641   // First Mother Volume containing SSDFlex
2642   /////////////////////////////////////////////////////////////
2643   TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2644   ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2645                                                                     ymothervertex);
2646   ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2647   ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2648   TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2649 //  TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2650 //                                                                                       fSSDAir);
2651   /////////////////////////////////////////////////////////////
2652   // SSDFlex Layer Shapes
2653   /////////////////////////////////////////////////////////////
2654   for(Int_t i=0; i<kssdflexlayernumber; i++){
2655         ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2656                                                                    ymothervertex);
2657     ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2658         ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2659   }
2660   /////////////////////////////////////
2661   // Setting Layers into Mother Volume
2662   /////////////////////////////////////
2663   Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2664   TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2665                                                                                                  fSSDKaptonFlexMedium};
2666   const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2667                                                                                                         "AlFlexLay2","KaptonFlexLay2"};
2668   TGeoVolume* ssdflex[2*kssdflexlayernumber];
2669   TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2670   for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2671         ssdflex[i] = new TGeoVolume(ssdflexname[i],
2672                                                                 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2673                                                                 i%2==0 ? ssdflexmed[0]   : ssdflexmed[1]);
2674         ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2675     ssdflextrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2676                                          +                                         fgkSSDFlexHeight[1]));
2677     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2678   }
2679   return ssdflexmother;
2680 }
2681 /////////////////////////////////////////////////////////////////////////////////
2682 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2683   /////////////////////////////////////////////////////////////
2684   // Method generating SSD End Flex
2685   /////////////////////////////////////////
2686   Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2687                                                         /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2688   Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2689                                                 * TMath::DegToRad()*ssdflexradiusmax
2690                                                 - fgkSSDFlexLength[2]-TMath::Pi()
2691                                                 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2692                                                         - 0.1*fgkSSDFlexFullLength;
2693   const Int_t knedges = 20;
2694   const Int_t karcnumber = 2;
2695   TVector3* vertexposition[karcnumber*(knedges+1)];
2696   Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2697   Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2698   Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2699   Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2700                                                                                  - 90.0*TMath::DegToRad()};
2701   TVector3* referencetrans[karcnumber];
2702   referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2703                                         +                          radius[0]*SinD(2.*fgkSSDFlexAngle),
2704                                    radius[0], 0);
2705   referencetrans[1] = new TVector3(referencetrans[0]->X()
2706                                         +              fgkSSDFlexLength[2],
2707                                    -              fgkSSDStiffenerHeight, 0);
2708 for(Int_t i=0; i<karcnumber; i++){
2709         for(Int_t j=0; j<knedges+1; j++){
2710                 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2711                                                          radius[i]*SinD(angle[i]), 0);
2712                 angle[i] +=  deltangle[i]*(1.0-2.0*i);
2713         }
2714   }
2715   ///////////////////////
2716   // Setting the vertices
2717   ///////////////////////
2718   const Int_t kendflexlayernumber = 4;
2719   const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2720   TVector3** vertex[kendflexlayernumber];
2721   for(Int_t i=0; i<kendflexlayernumber; i++)
2722                                         vertex[i] = new TVector3*[kendflexvertexnumber];
2723   TVector3* transvector[kendflexlayernumber+1];
2724   TVector3* deltatransvector = new TVector3();
2725   for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2726   transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2727                                 +                radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2728   for(Int_t i=1; i<kendflexlayernumber+1; i++){
2729         deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2730                                         *                 CosD(fgkSSDFlexAngle),
2731                                                           (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2732                                         *         SinD(fgkSSDFlexAngle),0.0);
2733         *transvector[i] = *transvector[i-1]+*deltatransvector;
2734   }
2735   Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2736   ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2737   for(Int_t i=0; i<karcnumber; i++){
2738         for(Int_t j=1; j<kendflexlayernumber+1; j++){
2739                 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2740                                                   * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2741                                               /radius[i];
2742         }
2743   }
2744   for(Int_t i=0; i<kendflexlayernumber; i++){
2745     vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y(),0);
2746     vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y(),0);
2747         for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2748                 if(j<(knedges+1)){
2749                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2750                                                 vertexposition[j]->Y()*ratioradius[0][i+1], 0);
2751                         vertex[i][j+2]->RotateZ(referenceangle[0]);
2752                         *vertex[i][j+2] += *referencetrans[0];
2753                         vertex[i][4*(knedges+1)-j+1] =
2754                                                          new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2755                                  vertexposition[j]->Y()*ratioradius[0][i], 0);
2756                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2757                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2758                 }
2759                 else{
2760
2761                         vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2762                                                 vertexposition[j]->Y()*ratioradius[1][i+1],0);
2763                         vertex[i][j+2]->RotateZ(referenceangle[1]);
2764                         *vertex[i][j+2] += *referencetrans[1];
2765                         vertex[i][4*(knedges+1)-j+1] =
2766                                                          new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2767                                        vertexposition[j]->Y()*ratioradius[1][i],
2768                                        0);
2769                         vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2770                         *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2771            }
2772         }
2773   }
2774   /////////////////////////////////////////////////////////////
2775   // First Mother Volume containing SSDEndFlex
2776   /////////////////////////////////////////////////////////////
2777   TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2778   Double_t xmothervertex[kendflexvertexnumber];
2779   Double_t ymothervertex[kendflexvertexnumber];
2780   xmothervertex[0] = vertex[0][0]->X();
2781   ymothervertex[0] = vertex[0][0]->Y();
2782   for(Int_t i=1; i<kendflexvertexnumber; i++){
2783         if(i<2*(knedges+1)+2){
2784                 xmothervertex[i] = vertex[3][i]->X();
2785                 ymothervertex[i] = vertex[3][i]->Y();
2786         }
2787         else{
2788                 xmothervertex[i] = vertex[0][i]->X();
2789                 ymothervertex[i] = vertex[0][i]->Y();
2790         }
2791   }
2792   ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2793                                                                            xmothervertex,ymothervertex);
2794   ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2795   ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2796 //  TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2797 //                                                               ssdendflexmothershape,fSSDAir);
2798   TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
2799   //////////////////////////////////////
2800   // End Flex TGeoXtru Layer Definition
2801   //////////////////////////////////////
2802   TGeoXtru* ssdendflexshape[kendflexlayernumber];
2803   TGeoVolume* ssdendflex[kendflexlayernumber];
2804   for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2805   Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2806   Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2807   Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2808   TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2809                                                                                                         fSSDKaptonFlexMedium};
2810   const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2811                                                                                                          "AlEndFlexLay2","KaptonEndFlexLay2"};
2812   for(Int_t i=0; i<kendflexlayernumber; i++){
2813         for(Int_t j=0; j<4*(knedges+1)+2; j++){
2814                 xvertex[i][j] = vertex[i][j]->X();
2815                 yvertex[i][j] = vertex[i][j]->Y();
2816         }
2817   ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2818   ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2819   ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2820   ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2821                                                                  i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2822   ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2823   ssdendflexmother->AddNode(ssdendflex[i],1);
2824   }
2825   /////////////////////////////////////////////////////////////
2826   // Deallocating memory
2827   /////////////////////////////////////////////////////////////
2828   for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2829   for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2830   for(Int_t i=0; i<kendflexlayernumber; i++){
2831         for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2832         delete [] vertex[i];
2833   }
2834   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2835   delete deltatransvector;
2836   /////////////////////////////////////////////////////////////
2837   //ssdendflexmother->CheckOverlaps(0.01);
2838   return ssdendflexmother;
2839 }
2840 ///////////////////////////////////////////////////////////////////////////////
2841 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2842   /////////////////////////////////////////////////////////////
2843   // Method generating the Mounting Block
2844   /////////////////////////////////////////////////////////////
2845   const Int_t kvertexnumber = 8;
2846   Double_t xvertex[kvertexnumber];
2847   Double_t yvertex[kvertexnumber];
2848   xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2849   xvertex[1] = xvertex[0];
2850   xvertex[2] = -xvertex[0];
2851   xvertex[3] = xvertex[2];
2852   xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2853                          -                                 fgkSSDMountingBlockLength[2]);
2854   xvertex[5] = xvertex[4];
2855   xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2856                          - 0.5*fgkSSDMountingBlockScrewHoleEdge
2857                          -     fgkSSDMountingBlockScrewHoleRadius[0];
2858   xvertex[7] = xvertex[6];
2859   yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2860                          +      fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2861   yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2862   yvertex[2] = yvertex[1];
2863   yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2864   yvertex[4] = yvertex[3];
2865   yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2866                          - fgkSSDMountingBlockHeight[0];
2867   yvertex[6] = yvertex[5];
2868   yvertex[7] = yvertex[0];
2869
2870   ///////////////////////////////////////////////////////////////////////
2871   // TGeoXTru Volume definition for Mounting Block Part
2872   ///////////////////////////////////////////////////////////////////////
2873   TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2874   ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2875   ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2876   ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2877   TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2878                                                                           ssdmountingblockshape,
2879                                                                                   fSSDMountingBlockMedium);
2880   ssdmountingblock->SetLineColor(fColorG10);
2881   TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2882   mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2883   TGeoRotation* mountingblockrot = new TGeoRotation();
2884   mountingblockrot->SetAngles(90.,180.,-90.);
2885   mountingblockcombitrans->SetRotation(*mountingblockrot);
2886   /////////////////////////////////////////////////////////////
2887   // Generating the Mounting Block Screw Vertices
2888   /////////////////////////////////////////////////////////////
2889   const Int_t kscrewvertexnumber = 15;
2890   Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2891                                  -                                      fgkSSDMountingBlockScrewHoleEdge)
2892                                  /                              fgkSSDMountingBlockScrewHoleRadius[0])
2893                                  * TMath::RadToDeg();
2894   Double_t phi0 = 90.+alpha;
2895   Double_t phi = 270.-2*alpha;
2896   Double_t deltaphi = phi/kscrewvertexnumber;
2897   TVector3* screwvertex[kscrewvertexnumber+1];
2898   for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2899         screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2900                                    *CosD(phi0+i*deltaphi),
2901                                    fgkSSDMountingBlockScrewHoleRadius[0]
2902                                       *SinD(phi0+i*deltaphi), 0);
2903   Double_t xscrewvertex[kscrewvertexnumber+6];
2904   Double_t yscrewvertex[kscrewvertexnumber+6];
2905   xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2906   yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2907                                   -               fgkSSDMountingBlockScrewHoleEdge);
2908   xscrewvertex[1] = xscrewvertex[0];
2909   yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2910   xscrewvertex[2] = screwvertex[0]->X();
2911   yscrewvertex[2] = yscrewvertex[1];
2912   for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2913         xscrewvertex[i+3] = screwvertex[i]->X();
2914         yscrewvertex[i+3] = screwvertex[i]->Y();
2915   }
2916   xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2917   yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2918   xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2919   yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2920   TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2921   ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2922   ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2923   ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2924                                                         +                                  fgkSSDMountingBlockHeight[2]);
2925   TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2926                                                                                 ssdmountingblockscrewshape,
2927                                                                                             fSSDMountingBlockMedium);
2928   ssdmountingblockscrew->SetLineColor(fColorG10);
2929   TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2930   for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2931   ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2932                                                                         -                                yscrewvertex[1],
2933                                                                                                          0.5*fgkSSDMountingBlockHeight[0]
2934                                                                         -                                fgkSSDMountingBlockHeight[2]
2935                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2936                                                                         +                                fgkSSDMountingBlockHeight[2]
2937                                                                         -                                yvertex[0]));
2938   ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2939                                                                                                         -0.5*fgkSSDMountingBlockScrewHoleEdge,
2940                                                                                                                  yscrewvertex[1]
2941                                                                                                         -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2942                                                                                                          +fgkSSDMountingBlockHeight[2]
2943                                                                                                          -yvertex[0]));
2944   ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2945                                                                                                           yscrewvertex[1],
2946                                                                         -                                 0.5*fgkSSDMountingBlockHeight[0]
2947                                                                         +                                 fgkSSDMountingBlockHeight[2]
2948                                                                         -                                 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2949                                                                         +                                 fgkSSDMountingBlockHeight[2]
2950                                                                         -                                 yvertex[0]));
2951   ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2952                                                                                                          yscrewvertex[1],
2953                                                                         -                                yscrewvertex[1]
2954                                                                         +                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2955                                                                         +                                fgkSSDMountingBlockHeight[2]
2956                                                                         -                                yvertex[0]));
2957   TGeoRotation* ssdmountingblockscrewrot[4];
2958   for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2959         ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2960     ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2961     ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2962   for(Int_t i=1; i<4; i++)
2963         ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2964   TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2965   ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2966   TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2967   ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2968                                                          +                                xvertex[0],yscrewvertex[1]
2969                                                          -                                0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970                                                          +                                fgkSSDMountingBlockHeight[2]
2971                                                          -                                yvertex[0]),0.);
2972   TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2973   for(Int_t i=0; i<4; i++){
2974         ssdmountingblockscrewmatrix[i] =
2975                 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2976         ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2977   }
2978   ///////////////////////////////////////////////////////////////////////
2979   // TGeoXtru for Mother Volume
2980   ///////////////////////////////////////////////////////////////////////
2981   const Int_t kvertexmothernumber = 12;
2982   Double_t xmothervertex[kvertexmothernumber];
2983   Double_t ymothervertex[kvertexmothernumber];
2984   for(Int_t i=0; i<6; i++){
2985         xmothervertex[i] = xvertex[i];
2986         ymothervertex[i] = yvertex[i];
2987   }
2988   xmothervertex[6]  = xvertex[5]+fgkSSDMountingBlockLength[2];
2989   ymothervertex[6]  = ymothervertex[5];
2990   xmothervertex[7]  = xmothervertex[6];
2991   ymothervertex[7]  = ymothervertex[4] - fgkSSDTolerance;
2992   xmothervertex[8]  = xmothervertex[7]
2993                                         + 0.5*(fgkSSDMountingBlockLength[1]
2994                                         -          fgkSSDMountingBlockLength[2]);
2995   ymothervertex[8]  = ymothervertex[7];
2996   xmothervertex[9]  = xmothervertex[8];
2997   ymothervertex[9]  = ymothervertex[2];
2998   xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
2999   ymothervertex[10] = ymothervertex[1];
3000   xmothervertex[11] = xmothervertex[10];
3001   ymothervertex[11] = ymothervertex[0];
3002   TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3003   ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3004   ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3005   ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3006   TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3007                                                                           ssdmountingblockmothershape,
3008                                                                                   fSSDAir);
3009   /////////////////////////////////////////////////////////////
3010   // Placing the Volumes into Mother Volume
3011   /////////////////////////////////////////////////////////////
3012   ssdmountingblockmother->AddNode(ssdmountingblock,1);
3013   ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3014   for(Int_t i=0; i<4; i++)
3015         ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3016                                                                         ssdmountingblockscrewmatrix[i]);
3017   /////////////////////////////////////////////////////////////
3018   // Deallocating memory
3019   /////////////////////////////////////////////////////////////
3020   delete mountingblockrot;
3021   for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3022   delete ssdmountingblockglobalrot;
3023   delete ssdmountingblockglobaltrans;
3024   /////////////////////////////////////////////////////////////
3025   return ssdmountingblockmother;
3026 }
3027 ///////////////////////////////////////////////////////////////////////////////
3028  TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3029   /////////////////////////////////////////////////////////////
3030   // Method generating the Mounting Block Clip
3031   /////////////////////////////////////////////////////////////
3032   const Int_t kmothervertexnumber = 10;
3033   Double_t xmothervertex[kmothervertexnumber];
3034   Double_t ymothervertex[kmothervertexnumber];
3035   xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3036                                    - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3037   xmothervertex[1] = xmothervertex[0];
3038   xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3039                                    - fgkMountingBlockClibScrewRadius);
3040   xmothervertex[3] = xmothervertex[2];
3041   xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3042   xmothervertex[5] = xmothervertex[4];
3043   xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3044   xmothervertex[7] = xmothervertex[6];
3045   xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3046   xmothervertex[9] = xmothervertex[8];
3047   ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3048                                + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3049   ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3050   ymothervertex[2] = ymothervertex[1];
3051   ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3052                                    - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3053                                    - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3054   ymothervertex[4] = ymothervertex[3];
3055   ymothervertex[5] = ymothervertex[2];
3056   ymothervertex[6] = ymothervertex[5];
3057   ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3058   ymothervertex[8] = ymothervertex[7];
3059   ymothervertex[9] = ymothervertex[0];
3060
3061   ///////////////////////////////////////////////////////////////////////
3062   // TGeoXTru Volume definition for Mounting Block Clip Part
3063   ///////////////////////////////////////////////////////////////////////
3064   TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3065   ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3066   ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3067   ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3068   TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3069                                                                           ssdmountingblockclipshape,fSSDAir);
3070   ssdmountingblockclip->SetLineColor(4);
3071   ///////////////////////////////////////////////////////////////////////
3072   // TGeoXTru Volume definition for Clip
3073   ///////////////////////////////////////////////////////////////////////
3074   const Int_t kclipvertexnumber = 6;
3075   Double_t xclipvertex[kclipvertexnumber];
3076   Double_t yclipvertex[kclipvertexnumber];
3077   xclipvertex[0] = xmothervertex[0];
3078   xclipvertex[1] = xclipvertex[0];
3079   xclipvertex[2] = xmothervertex[6];
3080   xclipvertex[3] = xclipvertex[2];
3081   xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3082   xclipvertex[5] = xclipvertex[4];
3083   yclipvertex[0] = ymothervertex[0];
3084   yclipvertex[1] = ymothervertex[1];
3085   yclipvertex[2] = yclipvertex[1];
3086   yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3087   yclipvertex[4] = yclipvertex[3];
3088   yclipvertex[5] = yclipvertex[0];
3089   TGeoXtru* clipshape = new TGeoXtru(2);
3090   clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3091   clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3092   clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3093                                                          +   fgkMountingBlockClibWidth);
3094   TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3095   clip->SetLineColor(18);
3096   ///////////////////////////////////////////////////////////////////////
3097   // Ladder Support Piece
3098   ///////////////////////////////////////////////////////////////////////
3099   const Int_t ksupportvertexnumber = 4;
3100   Double_t xsupportvertex[ksupportvertexnumber];
3101   Double_t ysupportvertex[ksupportvertexnumber];
3102   xsupportvertex[0] = xclipvertex[5];
3103   xsupportvertex[1] = xsupportvertex[0];
3104   xsupportvertex[2] = xmothervertex[9];
3105   xsupportvertex[3] = xsupportvertex[2];
3106   ysupportvertex[0] = yclipvertex[0];
3107   ysupportvertex[1] = yclipvertex[3];
3108   ysupportvertex[2] = ysupportvertex[1];
3109   ysupportvertex[3] = ysupportvertex[0];
3110   TGeoXtru* supportshape = new TGeoXtru(2);
3111   supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3112   supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3113   supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3114   TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3115   support->SetLineColor(9);
3116   ///////////////////////////////////////////////////////////////////////
3117   // TGeoXTru Volume definition for Screw
3118   ///////////////////////////////////////////////////////////////////////
3119   Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3120                                                 0.5*fgkMountingBlockClibScrewRadius};
3121   Int_t edgesnumber[2] = {50,6};
3122   Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3123                                                  +0.5*(ymothervertex[3]-ymothervertex[2])};
3124   TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3125   TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3126   clipscrew->SetLineColor(12);
3127   TGeoRotation* screwrot = new TGeoRotation();
3128   screwrot->SetAngles(0.,90.,0.);
3129   TGeoTranslation* screwtrans = new TGeoTranslation();
3130   screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3131                                                          0.5*(ymothervertex[3]+ymothervertex[2]),
3132                                                          0.5*fgkSSDMountingBlockWidth+
3133                                                         -0.5*fgkMountingBlockSupportWidth[0]);
3134   TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3135   ///////////////////////////////////////////////////////////////////////
3136   // Placing the Volumes
3137   ///////////////////////////////////////////////////////////////////////
3138   ssdmountingblockclip->AddNode(clip,1);
3139   ssdmountingblockclip->AddNode(support,1);
3140   ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3141   /////////////////////////////////////////////////////////////
3142   // Deallocating memory
3143   /////////////////////////////////////////////////////////////
3144   delete screwtrans;
3145   delete screwrot;
3146   /////////////////////////////////////////////////////////////
3147   return ssdmountingblockclip;
3148 }
3149 ///////////////////////////////////////////////////////////////////////////////
3150 void AliITSv11GeometrySSD::CreateCoolingTubes() {
3151   /////////////////////////////////////////////////////////////
3152   // Method generating the Cooling Tube
3153   // sets fcoolingtube and returns list for endladdercoolingtube
3154   /////////////////////////////////////////////////////////////
3155   TGeoTube *coolingtubeshape[2];
3156   // Ladder Cooling Tubes
3157
3158   // MvL: Simplified cooling tubes
3159   coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3160   coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3161
3162   // End Ladder Cooling Tubes
3163   TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3164   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3165     endladdercoolingtubeshape[i] = new  TGeoTube*[2];
3166
3167   Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3168   endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3169                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3170   endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3171                                                  endladdercoolingtubeshape[0][0]->GetDz());
3172   endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3173                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3174   endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3175                                                  endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3176   // Ladder Cooling Tubes
3177   TGeoVolume* coolingtube[2];
3178   coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3179   coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3180   coolingtube[0]->SetLineColor(fColorPhynox);
3181   coolingtube[1]->SetLineColor(fColorWater);
3182
3183   // End Ladder Cooling Tubes
3184   TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3185   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3186     endladdercoolingtube[i] = new TGeoVolume*[2];
3187   endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3188                                               endladdercoolingtubeshape[0][0],
3189                                               fSSDCoolingTubePhynox);
3190   endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3191                                               endladdercoolingtubeshape[0][1],
3192                                               fSSDCoolingTubeWater);
3193   endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3194                                               endladdercoolingtubeshape[1][0],
3195                                               fSSDCoolingTubePhynox);
3196   endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3197                                               endladdercoolingtubeshape[1][1],
3198                                               fSSDCoolingTubeWater);
3199   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3200     endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3201     endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3202   }
3203
3204   /////////////////////////////////////////////////////////////
3205   // Virtual Volume containing Cooling Tubes
3206   /////////////////////////////////////////////////////////////
3207   // Ladder Cooling Tubes
3208   TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3209                                                    coolingtubeshape[0]->GetRmax(),
3210                                                    coolingtubeshape[0]->GetDz());
3211   fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3212   fcoolingtube->AddNode(coolingtube[0],1);
3213   fcoolingtube->AddNode(coolingtube[1],1);
3214
3215   // End Ladder Cooling Tubes
3216   TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3217   for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3218     endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3219                                                        endladdercoolingtubeshape[i][0]->GetRmax(),
3220                                                        endladdercoolingtubeshape[i][0]->GetDz());
3221   fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3222                                             endladdervirtualcoolingtubeshape[0],
3223                                             fSSDAir);
3224   fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3225                                             endladdervirtualcoolingtubeshape[1],
3226                                             fSSDAir);
3227   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3228   fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3229   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3230   fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3231 }
3232 ///////////////////////////////////////////////////////////////////////////////
3233 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3234   /////////////////////////////////////////////////////////////
3235   // Method generating SSD Cooling Block
3236   /////////////////////////////////////////////////////////////
3237   const Int_t kvertexnumber = 8;
3238   ///////////////////////////////////////
3239   // Vertex Positioning for TGeoXTru
3240   ///////////////////////////////////////
3241   TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3242   vertexposition[0] = new TVector3(0.0,0.0, 0.);
3243   vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1],0);
3244   vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3245                                    vertexposition[1]->Y(),0);
3246   vertexposition[3] = new TVector3(vertexposition[2]->X(),
3247                                    vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2],0);
3248   vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y(),0);
3249   vertexposition[5] = new TVector3(vertexposition[4]->X(),
3250                                    + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1],0);
3251   vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3252                                           vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3253                                         - fgkSSDCoolingBlockHoleLength[0]
3254                                         - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3255                                           fgkSSDCoolingBlockHeight[0]
3256                                         - fgkSSDCoolingBlockHoleRadius[1],
3257                                                 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0], 0);
3258   vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3259                                         - fgkSSDCoolingBlockHoleLength[0]),
3260                                    vertexposition[6]->Y(), 0);
3261   Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3262                            / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3263   Double_t phi = 180.-alpha;
3264   Double_t psi = 180.+2.*alpha;
3265   Double_t deltapsi = psi/nedges;
3266   Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3267   TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3268                                        fgkSSDCoolingBlockHoleCenter, 0);
3269   for(Int_t i=0; i<nedges+1; i++){
3270         vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3271                                                    radius*SinD(phi+i*deltapsi),
3272                                                    0);
3273    *vertexposition[kvertexnumber+i] += (*transvector);
3274   }
3275   Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3276   for(Int_t i=0; i<kvertexnumber; i++)
3277     vertexposition[kvertexnumber+nedges+1+i] =
3278                                                 GetReflection(vertexposition[kvertexnumber-1-i],param);
3279   ///////////////////////////////////////////////////////////////////////
3280   // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3281   ///////////////////////////////////////////////////////////////////////
3282   TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3283   Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3284   Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3285   for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3286         xvertexpoints[i] = vertexposition[i]->X();
3287         yvertexpoints[i] = vertexposition[i]->Y();
3288   }
3289   ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3290                                                                                         yvertexpoints);
3291   ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3292   ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3293   TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3294                                                                           ssdcoolingblockshape,
3295                                                                                   fSSDAlCoolBlockMedium);
3296   ssdcoolingblock->SetLineColor(fColorAl);
3297   /////////////////////////////////////////////////////////////
3298   // Deallocating memory
3299   /////////////////////////////////////////////////////////////
3300   delete [] vertexposition;
3301   delete [] xvertexpoints;
3302   delete [] yvertexpoints;
3303   /////////////////////////////////////////////////////////////
3304   return ssdcoolingblock;
3305 }
3306 /////////////////////////////////////////////////////////////////////////////////
3307 void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
3308   ///////////////////////////////////////////////////////
3309   static const Int_t kssdchipcablesnumber    = 2;  // Number of cables: left and right
3310   static const Int_t kssdchipcableslaynumber = 2;  // Number of layers: Al and Kapton
3311   static const Int_t kvertexnumber                        = 4*(nedges+1)+4;
3312   Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3313   Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3314   ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
3315                                                  -  fgkSSDChipCablesHeight[0]
3316                                                  -  fgkSSDChipCablesHeight[1]);
3317   ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3318   Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3319   ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3320                                                           - 2.*TMath::Pi()*ssdchipcablesradius[0]
3321                                                           - ssdchipcablesradius[0]
3322                                                           - fgkSSDChipCablesWidth[1]
3323                                                           - fgkSSDChipCablesWidth[2]);
3324   ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3325                                                           - 0.5*(fgkSSDModuleStiffenerPosition[1]
3326                                                           +      fgkSSDChipCablesHeight[1]
3327                                                           +      fgkSSDSensorHeight);
3328   ///////////////////////////////////////////////////////
3329   // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3330   ///////////////////////////////////////////////////////
3331   TVector3** vertexposition[kssdchipcableslaynumber];
3332   for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3333                                                                                                   new TVector3*[4*(nedges+1)+4];
3334   Double_t ratio[4];
3335   ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3336   ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3337                    /  ssdchipcablesradius[0];
3338   ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3339                    /  ssdchipcablesradius[0];
3340   ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3341                    +  fgkSSDChipCablesHeight[1])
3342                    /  ssdchipcablesradius[0];
3343   Double_t phi = 180.;
3344   Double_t deltaphi = 180./nedges;
3345   Double_t angle = 0.0;
3346
3347   Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3348   Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3349
3350   TVector3* vertex = new TVector3();
3351   TVector3* transvector[kssdchipcableslaynumber];
3352   transvector[0] = new TVector3(fgkSSDChipWidth,
3353                                 SSDChipCablesHeight-ssdchipcablesradius[0], 0);
3354   transvector[1] = new TVector3();
3355   TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3356   TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3357   const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
3358                 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3359                  "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3360   for(Int_t k=0; k<kssdchipcablesnumber; k++){
3361         transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3362         transvector[1]->SetY(ssdchipcablesradius[0]
3363                                  +               fgkSSDChipCablesHeight[0]
3364                                  +               fgkSSDChipCablesHeight[1]);
3365         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3366                 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
3367                                               - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1], 0);
3368                 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
3369                                                     - i*fgkSSDChipCablesHeight[0], 0);
3370                 vertexposition[i][2*(nedges+1)+2] =
3371                                         new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3372                                 +                                fgkSSDChipCablesWidth[1]
3373                                 +                                fgkSSDChipCablesWidth[2],
3374                                                                 ((1.-i)*fgkSSDChipCablesHeight[i]
3375                                 + fgkSSDChipCablesHeight[1]), 0);
3376         vertexposition[i][2*(nedges+1)+3] =
3377                                         new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3378                                                                  vertexposition[i][2*(nedges+1)+2]->Y()
3379                        - fgkSSDChipCablesHeight[i], 0);
3380             for(Int_t j=0; j<nedges+1; j++){
3381                     angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3382                         vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3383                         vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3384                         vertexposition[0][(nedges+1)*i+j+2] =
3385                                                 new TVector3(*vertex+*transvector[i]);
3386                         vertexposition[1][(nedges+1)*i+j+2] =
3387                                                 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3388                                        vertex->Y()*ratio[2*i]+transvector[i]->Y(), 0);
3389                         vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3390                                                 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3391                         vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3392                                                 new TVector3(vertex->X()*ratio[2*i+1]
3393                                                         +                        transvector[i]->X(),
3394                                                                                  vertex->Y()*ratio[2*i+1]
3395                                        + transvector[i]->Y(), 0);
3396                 }
3397         }
3398         for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3399                 for(Int_t j=0; j<kvertexnumber; j++){
3400                         xvertexpoints[i][j] = vertexposition[i][j]->X();
3401                         yvertexpoints[i][j] = vertexposition[i][j]->Y();
3402                 }
3403                 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3404                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3405                                                                                 xvertexpoints[i],yvertexpoints[i]);
3406                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3407                 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3408                 ssdchipcable[kssdchipcablesnumber*k+i] =
3409                                 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3410                                                            ssdchipcableshape[kssdchipcablesnumber*k+i],
3411                                                           (kssdchipcablesnumber*k+i)%2==0?
3412                                                            fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3413                 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3414         }
3415         for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3416                 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3417   }
3418   /////////////////////////////////////////////////////////////
3419   // Mother Volume definition
3420   /////////////////////////////////////////////////////////////
3421   static const Int_t kmothervertexnumber = 8;
3422   Double_t xmothervertex[kmothervertexnumber];
3423   Double_t ymothervertex[kmothervertexnumber];
3424   xmothervertex[0] = xvertexpoints[0][1];
3425   ymothervertex[0] = yvertexpoints[0][1];
3426   xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3427   ymothervertex[1] = yvertexpoints[0][1];
3428   xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3429   ymothervertex[2] = yvertexpoints[0][2+nedges];
3430   xmothervertex[3] = xvertexpoints[0][3+nedges];
3431   ymothervertex[3] = yvertexpoints[0][3+nedges];
3432   xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3433   ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
3434   xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3435   ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
3436   xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3437   ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3438   xmothervertex[7] = xvertexpoints[0][1];
3439   ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3440   TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3441   ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3442   ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3443   ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3444
3445   cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3446   cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3447
3448   cableL->AddNode(ssdchipcable[0],1);
3449   cableL->AddNode(ssdchipcable[1],1);
3450   cableR->AddNode(ssdchipcable[2],1);
3451   cableR->AddNode(ssdchipcable[3],1);
3452
3453   /////////////////////////////////////////////////////////////
3454   // Deallocating memory
3455   /////////////////////////////////////////////////////////////
3456   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3457   for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3458   delete vertex;
3459   /////////////////////////////////////////////////////////////
3460 }
3461 //_____________________________________________________________________________
3462 TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
3463   /////////////////////////////////////////////////////////////
3464   // SSD Chip Assembly Generation
3465   /////////////////////////////////////////////////////////////
3466   TGeoBBox* ssdchipcompshape[2];
3467   ssdchipcompshape[0] =  new TGeoBBox("SSDChipCompShape",
3468                                                                                 0.5*fgkSSDChipLength,
3469                                                                                 0.5*fgkSSDChipWidth,
3470                                                                                 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3471   ssdchipcompshape[1] =  new TGeoBBox("SSDChipGlueCompShape",
3472                                                                                 0.5*fgkSSDChipLength,
3473                                                                                 0.5*fgkSSDChipWidth,
3474                                                                                 0.5*fgkSSDChipGlueHeight);
3475   TGeoVolume* ssdchipcomp[2];
3476   ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3477   ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3478                                                                   fSSDChipGlueMedium);
3479   ssdchipcomp[0]->SetLineColor(fColorSilicon);
3480   ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3481   TGeoTranslation* ssdchipcomptrans[2];
3482   ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3483   ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3484   /////////////////////////////////////////////////////////////
3485   // Virtual Volume containing SSDChip
3486   /////////////////////////////////////////////////////////////
3487   TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3488                                                                                                                  0.5*fgkSSDChipWidth,
3489                                                                                                                  0.5*fgkSSDChipHeight);
3490   TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3491   /////////////////////////////////////////////////////////////
3492   for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3493   return ssdchip;
3494 }
3495 /////////////////////////////////////////////////////////////////////////////////
3496 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3497   /////////////////////////////////////////////////////////////
3498   // Method returning a List containing pointers to Ladder Cable Volumes
3499   //
3500   // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3501   //                                    each contains 2 volumes, one for polyamide and one for aluminium
3502   /////////////////////////////////////////////////////////////
3503   const Int_t kladdercablesegmentnumber = 2;
3504   /////////////////////////////////////////
3505   // LadderSegmentBBox Volume
3506   /////////////////////////////////////////
3507   static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
3508   const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3509                                 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3510
3511
3512   const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3513                                                   {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3514   static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3515
3516   static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3517                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3518                                                                                            0.5*fgkSSDFlexWidth[0],
3519                                                                                            0.5*fgkSSDLadderCableWidth,
3520                                                                        0.5*fgkSSDLadderCableHeight[0]),
3521                                                    new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3522                                                                                            0.5*fgkSSDFlexWidth[0],
3523                                                                                            0.5*fgkSSDLadderCableWidth,
3524                                                                                            fgkSSDLadderCableHeight[0]
3525                                                                                            +0.5*fgkSSDLadderCableHeight[1])
3526                                                                                    };
3527   static TGeoVolume* laddercablesegmentbboxassembly =                                              new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3528   static TGeoVolume* laddercablesegmentarbassembly =
3529                                                    new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3530
3531   static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3532   static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3533
3534   if (laddercablesegmentbboxshape[0] == 0) {
3535     // Initialise static shapes and volumes
3536   for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3537                                                   new TGeoBBox(laddercablesegmentbboxshapename[i],
3538                                                                            0.5*fgkSSDFlexWidth[0],
3539                                                                            0.5*fgkSSDLadderCableWidth,
3540                                                                            0.5*fgkSSDLadderCableHeight[i]);
3541
3542   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3543                         laddercablesegmentbbox[i] =
3544                                                   new TGeoVolume(laddercablesegmentbboxname[i],
3545                                                                                  laddercablesegmentbboxshape[i],
3546                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3547             fSSDKaptonLadderCableMedium));
3548                         laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3549                                                                                                                    fColorPolyhamide);
3550   }
3551
3552   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3553                 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3554                                                                                             laddercablesegmentbboxtrans[i]);
3555 /////////////////////////////////////////
3556 // LadderSegmentArb8 Volume
3557 /////////////////////////////////////////
3558   const Int_t kvertexnumber = 4;
3559   TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3560   for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3561                                                                                                   new TVector3*[kvertexnumber];
3562 //Shape Vertex Positioning
3563   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3564     laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0], 0);
3565         laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3566                                                               i*fgkSSDFlexHeight[0], 0);
3567         laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3568                                                                                    +                         fgkSSDFlexHeight[1]
3569                                                               + i*fgkSSDFlexHeight[0], 0);
3570         laddercablesegmentvertexposition[i][3] =
3571                                                    new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3572                                                                 laddercablesegmentvertexposition[i][2]->Y(), 0);
3573   }
3574   Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3575                                                                             {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3576   const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3577                                         {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3578
3579   for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3580                                         GetArbShape(laddercablesegmentvertexposition[i],
3581                                                                 laddercablesegmentwidth[i],
3582                                                                 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3583                                                                 laddercablesegmentarbshapename[i]);
3584   const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3585                                                   {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3586
3587   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3588                          laddercablesegmentarb[i] =
3589                                                    new TGeoVolume(laddercablesegmentarbname[i],
3590                                                                                   laddercablesegmentarbshape[i],
3591                                                                                   (i==0?fSSDAlTraceLadderCableMedium:
3592             fSSDKaptonLadderCableMedium));
3593                          laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3594                                                                                                                    fColorPolyhamide);
3595 }
3596   TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3597   laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3598                                                                                                  90.,90,-90.);
3599   laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3600                                                                                                   0.,90.,0.);
3601   TGeoCombiTrans* laddercablesegmentarbcombitrans =
3602                                                    new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3603                                                            0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3604                                                          + fgkSSDFlexWidth[0],0.,0.,
3605                                                    new TGeoRotation((*laddercablesegmentarbrot[1])
3606                                                      *(*laddercablesegmentarbrot[0])));
3607   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3608   laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3609                                                                                    laddercablesegmentarbcombitrans);
3610   }  // End of static initialisations
3611 /////////////////////////////////////////
3612 // End Ladder Cable Volume
3613 // Note: this part depends explicitly on the length passed as an argument to the function
3614 /////////////////////////////////////////
3615   TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3616   const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3617                                 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3618   for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3619                                                   new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3620                                                                            0.5*ssdendladdercablelength,
3621                                                                            0.5*fgkSSDLadderCableWidth,
3622                                                                            0.5*fgkSSDLadderCableHeight[i]);
3623   const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3624                                                   {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3625   TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3626   for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3627                         ladderendcablesegmentbbox[i] =
3628                                                   new TGeoVolume(ladderendcablesegmentbboxname[i],
3629                                                                                  ladderendcablesegmentbboxshape[i],
3630                                                                                  (i==0?fSSDAlTraceLadderCableMedium:
3631             fSSDKaptonLadderCableMedium));
3632                         ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3633                                                                                                                    fColorPolyhamide);
3634   }
3635   TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3636   ladderendcablesegmentbboxtrans[0] =
3637                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3638                                                                                            0.5*ssdendladdercablelength,
3639                                                                                            0.5*fgkSSDLadderCableWidth,
3640                                                                                            0.5*fgkSSDLadderCableHeight[0]);
3641   ladderendcablesegmentbboxtrans[1] =
3642                                                    new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3643                                                                                            0.5*ssdendladdercablelength,
3644                                                                                            0.5*fgkSSDLadderCableWidth,
3645                                                                                            fgkSSDLadderCableHeight[0]
3646                                                                                            +0.5*fgkSSDLadderCableHeight[1]);
3647   TGeoVolume* ladderendcablesegmentbboxassembly =
3648                                                    new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3649   for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3650                 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3651                                                                                             ladderendcablesegmentbboxtrans[i]);
3652 /////////////////////////////////////////
3653   TList* laddercablesegmentlist = new TList();
3654   laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3655   laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3656   laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3657   return laddercablesegmentlist;
3658 }
3659
3660 /////////////////////////////////////////////////////////////////////////////////
3661 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
3662   /////////////////////////////////////////////////////////////
3663   // Method generating Ladder Cable of given length (n modules + end)
3664   // Called by GetLadderCableAssembly
3665   /////////////////////////////////////////////////////////////
3666   TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3667   TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3668   for(Int_t i=0; i<n; i++){
3669          TGeoTranslation* laddercabletrans = new TGeoTranslation(
3670                                                         i*(fgkCarbonFiberJunctionWidth),
3671                                                         fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3672                                                         i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3673     laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
3674     if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3675
3676   }
3677   TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3678                                           (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3679                                                              fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3680                                                              (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3681   laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3682   return laddercable;
3683 }
3684 /////////////////////////////////////////////////////////////////////////////////
3685 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
3686   ///////////////////////////////////////////////////////////////////
3687   // Main method generating Ladder Cable bundles containing n cables
3688   ///////////////////////////////////////////////////////////////////
3689   Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3690   Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3691   TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
3692   TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
3693   char laddercabletransname[100];
3694   for(Int_t i=0; i<n; i++){
3695     snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3696     laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3697                          new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
3698   }
3699   return laddercable;
3700 }
3701 /////////////////////////////////////////////////////////////////////////////////
3702 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3703   /////////////////////////////////////////////////////////////
3704   // Method generating Ladder Cable List Assemblies
3705   // containing two cables bundles, i.e. P+N readout for one endcap
3706   /////////////////////////////////////////////////////////////
3707   const Int_t kladdercableassemblynumber = 2;
3708   TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3709   TGeoVolume* ladderCable[kladdercableassemblynumber];
3710   char laddercableassemblyname[100];
3711   TList* laddercableassemblylist = new TList();
3712   for(Int_t i=0; i<kladdercableassemblynumber; i++){
3713     snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
3714         ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3715         ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3716                                          new TGeoCombiTrans((n-1)
3717                                          *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3718                                              2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3719                                                                                         0.,new TGeoRotation("",180,0.,0.)));
3720         laddercableassemblylist->Add(ladderCable[i]);
3721 }
3722   return laddercableassemblylist;
3723 }
3724 ///////////////////////////////////////////////////////////////////////////////
3725 void AliITSv11GeometrySSD::SetLadderSegment(){
3726   /////////////////////////////////////////////////////////////
3727   // Method Generating Ladder Segment Array
3728   /////////////////////////////////////////////////////////////
3729   fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3730   fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
3731
3732   /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3733   TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3734   static const Int_t ntrianglevtx = 3;
3735   Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3736   Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3737   laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3738   laddersegmentshape->DefineSection(0,0);
3739   laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth);  // MVL
3740   fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3741   fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3742   */
3743
3744   if(!fCreateMaterials) CreateMaterials();
3745   if(!fTransformationMatrices) CreateTransformationMatrices();
3746   if(!fBasicObjects) CreateBasicObjects();
3747   for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3748   // Placing Carbon Fiber Support
3749         for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3750                 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3751                                                                                         fcarbonfibersupportmatrix[j]);
3752                 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3753                                                                                         fcarbonfibersupportmatrix[j]);
3754   }
3755   // Placing Carbon Fiber Junction
3756         for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
3757         fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3758                                                                    fcarbonfiberjunctionmatrix[j]);
3759   }
3760   // Placing Carbon Fiber Lower Support
3761     for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
3762                 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3763                                                            fcarbonfiberlowersupportrans[j]);
3764     }
3765   // Placing SSD Sensor Support
3766     for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
3767         fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
3768                                                                      fssdsensorsupport[1][i],
3769                                                            j+1,fssdsensorsupportmatrix[j]);
3770   // Placing SSD Cooling Tube Support
3771         for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3772                 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3773                                                                    fcoolingtubesupportmatrix[j]);
3774   // Placing SSD Cooling Tube
3775         fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3776         fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
3777   // Placing SSD Hybrid
3778     switch(i){
3779         case 0:
3780                 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3781                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3782                 break;
3783     case 1:
3784                 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3785                 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3786                 break;
3787         }
3788         // Placing Cooling Block System
3789       fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
3790         // Placing SSD Flex
3791       for(Int_t j=0; j<fgkflexnumber; j++){
3792         fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3793         fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3794       }
3795    }
3796 }
3797 ///////////////////////////////////////////////////////////////////////////////
3798 void AliITSv11GeometrySSD::SetEndLadderSegment(){
3799   /////////////////////////////////////////////////////////////
3800   // Method Generating End Ladder
3801   /////////////////////////////////////////////////////////////
3802   // End Ladder Carbon Fiber Junction
3803   /////////////////////////////////////////////////////////////
3804   fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3805   fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3806   if(!fCreateMaterials) CreateMaterials();
3807   if(!fTransformationMatrices) CreateTransformationMatrices();
3808   if(!fBasicObjects) CreateBasicObjects();
3809   for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3810         for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
3811                 fendladdersegment[i]->AddNode(j==2 ?
3812                                                         fendladdercarbonfiberjunction[i][1] :
3813                                                         fendladdercarbonfiberjunction[i][0],
3814                                                         j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3815   }
3816   /////////////////////////////////////////////////////////////
3817   // End Ladder Carbon Fiber Support
3818   /////////////////////////////////////////////////////////////
3819   for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3820       for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3821                   fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3822                   fendladdercarbonfibermatrix[i][j]);
3823           fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3824                   fendladdercarbonfibermatrix[i][j]);
3825       }
3826   /////////////////////////////////////////////////////////////
3827   // End Ladder Mounting Block
3828   /////////////////////////////////////////////////////////////
3829   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3830        fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
3831                                      fendladdermountingblockcombitrans[i]);
3832   /////////////////////////////////////////////////////////////
3833   // End Ladder Mounting Block Clip
3834   /////////////////////////////////////////////////////////////
3835   for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3836         for(Int_t j=0; j<2; j++)
3837                 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3838                                               fendladdermountingblockclipmatrix[i][j]);
3839   /////////////////////////////////////////////////////////////
3840   // End Ladder Lower Supports
3841   /////////////////////////////////////////////////////////////
3842   fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
3843                                 fendladderlowersupptrans[0]);
3844   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
3845                                 fendladderlowersupptrans[1]);
3846   fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
3847                                 fendladderlowersupptrans[2]);
3848   /////////////////////////////////////////////////////////////
3849   // End Ladder Cooling Tube Support
3850   /////////////////////////////////////////////////////////////
3851   for(Int_t i=0; i<2; i++)
3852         for(Int_t j=0; j<(i==0?4:2); j++)
3853                 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3854                                               fendladdercoolingtubesupportmatrix[i][j]);
3855   /////////////////////////////////////////////////////////////
3856   // End Ladder Cooling Tube Support
3857   /////////////////////////////////////////////////////////////
3858   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3859   fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3860   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3861   fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
3862 }
3863 ///////////////////////////////////////////////////////////////////////////////
3864 void AliITSv11GeometrySSD::SetLadder(){
3865   /////////////////////////////////////////////////////////////
3866   // Method Generating Ladder of Layer 5 and 6
3867   /////////////////////////////////////////////////////////////
3868   Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3869                                                                                                 fgkSSDLay6SensorsNumber};
3870   /////////////////////////////////////////////////////////////////////////////
3871   /// Generating Ladder Mother Volume Containing Ladder
3872   /////////////////////////////////////////////////////////////////////////////
3873   /*  TGeoXtru* laddershape[fgkladdernumber];
3874   for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3875   */
3876   const Int_t kmothervertexnumber = 8;
3877   Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3878   Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3879   ///////////////////////
3880   // Setting the vertices
3881   ///////////////////////
3882   Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3883                                                                 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
3884   xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
3885   ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
3886   xmothervertex[0][1] = xmothervertex[0][0];
3887   ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
3888   xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3889                                                 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3890   ymothervertex[0][2] = ymothervertex[0][1];
3891   ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3892   xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3893   xmothervertex[0][4] = -xmothervertex[0][3];
3894   ymothervertex[0][4] = ymothervertex[0][3];
3895   xmothervertex[0][5] = -xmothervertex[0][2];
3896   ymothervertex[0][5] = ymothervertex[0][2];
3897   xmothervertex[0][6] = -xmothervertex[0][1];
3898   ymothervertex[0][6] = ymothervertex[0][1];
3899   xmothervertex[0][7] = -xmothervertex[0][0];
3900   ymothervertex[0][7] = ymothervertex[0][0];
3901   for(Int_t i=0; i<kmothervertexnumber; i++){
3902         xmothervertex[1][i] = xmothervertex[0][i];
3903         ymothervertex[1][i] = ymothervertex[0][i];
3904   }
3905 ///////////////////////////////////////////////////////////////////////////
3906 // Disalignement Mother Volume corrections 25/08/08
3907 ///////////////////////////////////////////////////////////////////////////
3908   TGeoXtru* leftladdershape1[fgkladdernumber];
3909   TGeoXtru* leftladdershape2[fgkladdernumber];
3910   TGeoXtru* centersensorladdershape[fgkladdernumber];
3911   TGeoXtru* rightladdershape1[fgkladdernumber];
3912   TGeoXtru* rightladdershape2[fgkladdernumber];
3913   for(Int_t i=0; i<fgkladdernumber; i++){
3914     leftladdershape1[i] = new TGeoXtru(2);
3915     leftladdershape2[i] = new TGeoXtru(2);
3916     centersensorladdershape[i] = new TGeoXtru(2);
3917     rightladdershape1[i] = new TGeoXtru(2);
3918     rightladdershape2[i] = new TGeoXtru(2);
3919   }
3920   //////////////////////////////////////
3921   // Setting the names for shapes
3922   //////////////////////////////////////
3923   leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3924   leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3925   leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3926   leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
3927   centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3928   centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
3929   rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3930   rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3931   rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3932   rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
3933   //////////////////////////////////////
3934   Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3935   Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
3936   Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3937   Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
3938   Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3939   Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3940   for(Int_t i=0; i<fgkladdernumber; i++) {
3941     for(Int_t j=0; j<kmothervertexnumber; j++){
3942       xcentersensorvertex[i][j] = xmothervertex[i][j];
3943       ycentersensorvertex[i][j] = ymothervertex[i][j];
3944       xend1laddervertex[i][j] = xmothervertex[i][j];
3945       yend1laddervertex[i][j] = ymothervertex[i][j];
3946       xend2laddervertex[i][j] = xmothervertex[i][j];
3947       yend2laddervertex[i][j] = ymothervertex[i][j];
3948     }
3949     // Add some space around sensors to accommodate misalignments
3950     xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3951     xcentersensorvertex[i][1] =  xcentersensorvertex[0][0];
3952     xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3953     xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3954
3955     ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3956     ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3957
3958     // Center Ladder Piece
3959     centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3960                                               ycentersensorvertex[i]);
3961     centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3962                                                  + 1.45*fgkSSDMountingBlockWidth);
3963     centersensorladdershape[i]->DefineSection(1,   ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3964                                                  + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3965                                                  - 2.4*fgkSSDMountingBlockWidth);
3966
3967     // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
3968
3969     // Cuts off first corner (neg x)
3970     xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3971     xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3972     // Cuts off last part (pos x)
3973     xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3974     xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
3975
3976     leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3977                                        yend1laddervertex[i]);
3978     leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3979     leftladdershape1[i]->DefineSection(1,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3980                                          - fgkEndLadderMountingBlockPosition[0]);
3981
3982     leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3983                                        yend2laddervertex[i]);
3984     leftladdershape2[i]->DefineSection(0,  fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3985                                          - fgkEndLadderMountingBlockPosition[0]);
3986     leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3987                                        + 1.45*fgkSSDMountingBlockWidth);  // connect to main volume at -1.6725 cm
3988
3989     rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3990                                         yend1laddervertex[i]);
3991     rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3992                                         +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3993                                         -2.4*fgkSSDMountingBlockWidth);
3994     rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3995                                         + fgkEndLadderMountingBlockPosition[1]);
3996
3997     rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3998                                         yend2laddervertex[i]);
3999     rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4000                                            + fgkEndLadderMountingBlockPosition[1]);
4001     rightladdershape2[i]->DefineSection(1,  ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4002                                           + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4003   }
4004   TGeoCompositeShape* laddershapecontainer[2];
4005   laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4006                                                    "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4007                                                    "+Lay5CenterSensorContainer"
4008                                                    "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4009   laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4010                                                    "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4011                                                    "+Lay6CenterSensorContainer"
4012                                                    "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4013   const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4014   for(Int_t i=0; i<fgkladdernumber; i++){
4015     fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4016     fladder[i]->SetLineColor(4);
4017   }
4018 ///////////////////////////////////////////////////////////////////////////
4019  if(!fCreateMaterials) CreateMaterials();
4020  if(!fTransformationMatrices) CreateTransformationMatrices();
4021  if(!fBasicObjects) CreateBasicObjects();
4022  SetLadderSegment();
4023  SetEndLadderSegment();
4024   for(Int_t i=0; i<fgkladdernumber; i++){
4025         for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4026         //////////////////////////
4027         /// Placing Ladder Segment
4028         //////////////////////////
4029                 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4030                                                                      fladdersegment[i==0 ? 1 : 0],
4031                                                                          ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4032         //////////////////////////
4033         /// Placing SSD Sensor
4034         //////////////////////////
4035         if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
4036                 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4037                                                         fssdsensormatrix[i][j]);
4038         }
4039         ///////////////////////////////
4040         /// Placing End Ladder Segment
4041         ///////////////////////////////
4042         fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4043         fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4044    }
4045 /////////////////////////////////////////////////////////////////////////////
4046 /// Placing Ladder Cables
4047 /////////////////////////////////////////////////////////////////////////////
4048   Int_t sidecablenumber[2][2];
4049   sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4050   sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4051   sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4052   sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4053   Double_t carbonfibertomoduleposition[3];
4054   carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4055   carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4056                          fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4057          +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4058          -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4059          -            fgkSSDSensorCenterSupportThickness[0]);
4060   carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4061                                                                  +   0.5*fgkCoolingTubeSupportHeight
4062          -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4063   const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4064   Double_t ssdendladdercablelength[4];
4065   ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4066                                                          + fgkSSDSensorLength
4067                                                          - fgkSSDModuleStiffenerPosition[1]
4068                                                          - fgkSSDStiffenerWidth
4069                                                          - fgkSSDFlexWidth[0]
4070                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4071   ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4072                                                          + fgkSSDModuleStiffenerPosition[1]
4073                                                          + fgkSSDStiffenerWidth
4074                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4075   ssdendladdercablelength[2] = ssdendladdercablelength[1]
4076                                                          - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4077                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4078                                                          - kendladdercablecorrection;
4079   ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4080                                                          + carbonfibertomoduleposition[1]
4081                                                          - fgkSSDModuleStiffenerPosition[1]
4082                                                          - fgkSSDStiffenerWidth)
4083                                                          + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4084
4085   TList* laddercableassemblylist[4];
4086   const Int_t kendladdercablesnumber = 4;
4087   TGeoRotation *laddercablerot = new TGeoRotation();
4088   laddercablerot->SetAngles(90.,60.,-90.);
4089   for(Int_t i=0; i<fgkladdercablesnumber; i++)
4090         for(Int_t j=0; j<kendladdercablesnumber; j++){
4091                 laddercableassemblylist[j] =
4092                 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4093                                                                    ssdendladdercablelength[j]);
4094                         fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4095                                                                         j<2?1:2,fladdercablematrix[i][j]);
4096   }
4097 }
4098
4099 ////////////////////////////////////////////////////////////////////////////////
4100 void AliITSv11GeometrySSD::SetLayer(){
4101 ////////////////////////////////////////////////////////////////////////////////
4102   // Creating Ladder of Layer 5 and Layer 6
4103   /////////////////////////////////////////////////////////////
4104   if(!fCreateMaterials) CreateMaterials();
4105   if(!fTransformationMatrices) CreateTransformationMatrices();
4106   if(!fBasicObjects) CreateBasicObjects();
4107   SetLadder(); // Generating the ladder of Layer5 and Layer6
4108   const Int_t kssdlayladdernumber[fgklayernumber] =
4109                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4110   /////////////////////////////////////////////////////////////
4111   // Generating mother volumes for Layer5 and Layer6
4112   /////////////////////////////////////////////////////////////
4113   fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4114   fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4115   Int_t *ladderindex[fgklayernumber];
4116   Int_t index[fgklayernumber] = {8,9};
4117   for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4118   for(Int_t i=0; i<fgklayernumber; i++)
4119         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4120                 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4121                                                           j+index[i] : j+index[i]-kssdlayladdernumber[i];
4122                 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4123                         fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4124         }
4125   /////////////////////////////////////////////////////////////
4126   // Deallocating memory
4127   /////////////////////////////////////////////////////////////
4128   for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
4129 }
4130 ////////////////////////////////////////////////////////////////////////////////
4131 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4132   /////////////////////////////////////////////////////////////
4133   // Insert the layer 5 in the mother volume.
4134   /////////////////////////////////////////////////////////////
4135   if (! moth) {
4136     AliError("Can't insert layer5, mother is null!\n");
4137     return;
4138   };
4139   if(!fSSDLayer5) SetLayer();
4140   fMotherVol = moth;
4141   TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4142                                                                                 + fgkLay5CenterITSPosition);
4143   moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4144  }
4145 ////////////////////////////////////////////////////////////////////////////////
4146 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4147   /////////////////////////////////////////////////////////////
4148   // Insert the layer 6 in the mother volume.
4149   /////////////////////////////////////////////////////////////
4150   if (! moth) {
4151     AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4152     return;
4153   };
4154   if(!fSSDLayer6) SetLayer();
4155   fMotherVol = moth;
4156   TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4157                                                                                 + fgkLay6CenterITSPosition);
4158   moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4159  }
4160  ////////////////////////////////////////////////////////////////////////////////
4161  TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4162   /////////////////////////////////////////////////////////////
4163   // Method generating the Arc structure of Ladder Support
4164   /////////////////////////////////////////////////////////////
4165   const Int_t kssdlayladdernumber[fgklayernumber] =
4166                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4167   Double_t mountingsupportedge[fgklayernumber];
4168   Double_t mountingblockratio[fgklayernumber];
4169   Double_t theta[fgklayernumber];
4170   Double_t phi[fgklayernumber];
4171   Double_t psi0[fgklayernumber];
4172   Double_t deltapsi[fgklayernumber];
4173   TVector3* mountingsupportedgevector[fgklayernumber];
4174   for(Int_t i=0; i<fgklayernumber; i++){
4175         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4176     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4177                                                           * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4178                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4179                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4180                                                           / kssdlayladdernumber[i])));
4181     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4182     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4183         mountingsupportedgevector[i] = new TVector3();
4184         mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4185         mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4186                                                         (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4187                                                         (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
4188     psi0[i] = 0.5*TMath::Pi()-phi[i];
4189     deltapsi[i] = (theta[i]+phi[i])/nedges;
4190   }
4191   TVector3** vertex[fgklayernumber];
4192   TList* vertexlist[fgklayernumber];
4193   Int_t indexedge[fgklayernumber] = {0,0};
4194   for(Int_t i=0; i<fgklayernumber; i++){
4195         vertex[i] = new TVector3*[nedges+1];
4196         vertexlist[i] = new TList();
4197   }
4198   for(Int_t i=0; i<fgklayernumber; i++){
4199         for(Int_t j=0; j<nedges+1; j++){
4200                 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4201                                             fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]), 0);
4202                 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4203                 vertexlist[i]->Add(vertex[i][j]);
4204         }
4205         vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4206   }
4207   Double_t** xsidevertex = new Double_t*[fgklayernumber];
4208   Double_t** ysidevertex = new Double_t*[fgklayernumber];
4209   Double_t** xcentervertex = new Double_t*[fgklayernumber];
4210   Double_t** ycentervertex = new Double_t*[fgklayernumber];
4211   Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4212   Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4213   Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4214   Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4215   for(Int_t i=0; i<fgklayernumber; i++){
4216     xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4217     ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4218     xcentervertex[i] = new Double_t[indexedge[i]+3];
4219     ycentervertex[i] = new Double_t[indexedge[i]+3];
4220         xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4221         ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4222         xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4223         ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4224         for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4225                 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4226                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4227                 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4228                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4229                 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4230                 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4231                 if(j<indexedge[i]+1){
4232                         xcentervertex[i][j!=indexedge[i]?j+3:0] =
4233                                                                                 ((TVector3*)vertexlist[i]->At(j))->X();
4234                         ycentervertex[i][j!=indexedge[i]?j+3:0] =
4235                                                                                 ((TVector3*)vertexlist[i]->At(j))->Y();
4236                         xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4237                         ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4238                 }
4239         }
4240         xsidevertex[i][1] = xsidevertex[i][0];
4241         ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4242         xsidevertex[i][2] = xsidevertex[i][3];
4243         ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4244         xcentervertex[i][1] = xcentervertex[i][0];
4245         ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4246         xcentervertex[i][2] = xcentervertex[i][3];
4247         ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4248         xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4249         ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4250         xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4251         ycenterlowervertex[i][0] = ysidevertex[i][0];
4252         xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4253         ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4254   }
4255   /////////////////////////////////////////////////////////////
4256   // Building the Arc Structure of Ladder Supports
4257   /////////////////////////////////////////////////////////////
4258   TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4259   TGeoXtru* centermountingsupportshape[fgklayernumber];
4260   TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4261   TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4262   TGeoVolume* sidemountingblocksupport[fgklayernumber];
4263   TGeoVolume* centermountingblocksupport[fgklayernumber];
4264   TGeoVolume* sideladdersupportpiece[fgklayernumber];
4265   TGeoVolume* centerladdersupportpiece[fgklayernumber];
4266   char sidemountingblockname[100];
4267   char centermountingblockname[100];
4268   char sideladdersupportpiecename[100];
4269   char centerladdersupportpiecename[100];
4270   for(Int_t i=0; i<fgklayernumber; i++){
4271     snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4272     snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4273     snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4274     snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4275     sidemountingblocksupportshape[i] = new TGeoXtru(2);
4276     sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4277                                                                                                 xsidevertex[i],ysidevertex[i]);
4278     sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4279                                                                                                          -fgkMountingBlockSupportWidth[0]);
4280     sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4281     sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4282                                                                           sidemountingblocksupportshape[i],
4283                                                                                   fSSDAlCoolBlockMedium);
4284         sidemountingblocksupport[i]->SetLineColor(9);
4285         centermountingsupportshape[i] = new TGeoXtru(2);
4286     centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4287                                                                                                 xcentervertex[i],ycentervertex[i]);
4288         centermountingsupportshape[i]->DefineSection(0,0.);
4289     centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4290                                                                                                   -fgkMountingBlockSupportWidth[0]);
4291
4292     centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4293                                                                           centermountingsupportshape[i],
4294                                                                                   fSSDAlCoolBlockMedium);
4295         centermountingblocksupport[i]->SetLineColor(9);
4296         sideladdersupportpieceshape[i] = new TGeoXtru(2);
4297     sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4298                                                                                                 xsidelowervertex[i],ysidelowervertex[i]);
4299         sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4300                                                                                                          -fgkMountingBlockSupportWidth[0]);
4301     sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4302     sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4303                                                                           sideladdersupportpieceshape[i],
4304                                                                                   fSSDCarbonFiberMedium);
4305         sideladdersupportpiece[i]->SetLineColor(fColorAl);
4306         centerladdersupportpieceshape[i] = new TGeoXtru(2);
4307     centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4308                                                                                                 xcenterlowervertex[i],ycenterlowervertex[i]);
4309         centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4310     centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4311                                                                                                   -fgkMountingBlockSupportWidth[0]);
4312     centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4313                                                                           centerladdersupportpieceshape[i],
4314                                                                                   fSSDCarbonFiberMedium);
4315         centerladdersupportpiece[i]->SetLineColor(fColorAl);
4316   }
4317   /////////////////////////////////////////////////////////////
4318   // Building the Up Structure of Ladder Supports
4319   /////////////////////////////////////////////////////////////
4320   TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4321   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4322   TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4323   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4324   TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4325   //////////////////////////////////////////////////////////
4326   // Setting the volume for TGeoXtru Mounting Block Piece
4327   //////////////////////////////////////////////////////////
4328   TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4329   TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4330   TGeoVolume* mountingblockpiecedown[fgklayernumber];
4331   TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4332   TGeoVolume* mountingblockpieceup[fgklayernumber];
4333   Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4334   Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4335   Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4336   Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4337   char mountingblockpiecedownname[100];
4338   char mountingblockpieceupname[100];
4339   for(Int_t i=0; i<fgklayernumber; i++){
4340     ///////////////////////////
4341     // Mounting Block Down Vertex
4342     ///////////////////////////
4343         mountingblockpiecedownshape[i] = new TGeoXtru(2);
4344         snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
4345         mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4346         mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4347                                               + fgkMountingBlockSupportDownHeight
4348                                               - fgkSSDLadderVerticalDisalignment;
4349         mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4350         mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4351                                                                                 + fgkSSDMountingBlockHeight[1]
4352                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4353                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4354         mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4355         mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4356         mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4357         mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4358         mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4359         mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4360         mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4361         mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4362                                                                                 + fgkSSDMountingBlockHeight[2]
4363                                                                                 - fgkSSDMountingBlockHeight[0];
4364         mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4365         mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4366         mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4367         mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4368         mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4369                                                                                                          mountingblockpiecedownyvertex[i]);
4370         mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4371         mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4372         mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4373                                                                  mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4374         mountingblockpiecedown[i]->SetLineColor(fColorG10);
4375
4376     ///////////////////////////
4377     // Mounting Block Up Vertex
4378     ///////////////////////////
4379         mountingblockpieceupshape[i] = new TGeoXtru(2);
4380         snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
4381         mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4382         mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4383                                                                                 + fgkMountingBlockSupportUpHeight[i]
4384                                               - fgkSSDLadderVerticalDisalignment;
4385         mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4386         mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4387                                                                                 + fgkSSDMountingBlockHeight[1]
4388                                                                                 - 0.5*fgkCoolingTubeSupportHeight
4389                                                                                 - fgkSSDModuleCoolingBlockToSensor;
4390         mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4391         mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4392         mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4393         mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4394         mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4395         mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4396         mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4397         mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4398                                                                                 + fgkSSDMountingBlockHeight[2]
4399                                                                                 - fgkSSDMountingBlockHeight[0];
4400         mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4401         mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4402         mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4403         mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4404
4405         mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4406                                                                                                          mountingblockpieceupyvertex[i]);
4407         mountingblockpieceupshape[i]->DefineSection(0,0.0);
4408         mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4409         mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4410                                                                 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4411         mountingblockpieceup[i]->SetLineColor(fColorG10);
4412  }
4413   ///////////////////////////////////////////////////////////////////
4414   // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4415   ///////////////////////////////////////////////////////////////////
4416   TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4417   TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4418   TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4419   TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4420   Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4421   Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4422   Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4423   Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4424   char mountingblocksupportrapezoidowname[100];
4425   char mountingblocksupportrapezoidupname[100];
4426   Double_t scalefactor = 3./4.;
4427   for(Int_t i=0; i<fgklayernumber; i++){
4428   ////////////////////////////////////////////
4429   // Mounting Block Support Down Trapezoid Vertex
4430   ////////////////////////////////////////////
4431         mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4432         mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4433                                                                                                  - mountingsupportedge[i];
4434         mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4435         mountingblocksupportrapezoidownxvertex[i][1] =
4436                                                                                 mountingblocksupportrapezoidownxvertex[i][0];
4437         mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4438                                                                                                  + scalefactor*(mountingblockpiecedownyvertex[i][1]
4439                                                                                              - mountingblockpiecedownyvertex[i][0]);
4440         mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4441         mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4442         mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4443         mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4444         mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4445         mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4446
4447         mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4448                                                                                                                mountingblocksupportrapezoidownyvertex[i]);
4449         mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4450                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4451         mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4452         snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4453         mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4454                                                                 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4455         mountingblocksupportrapezoidown[i]->SetLineColor(9);
4456   ////////////////////////////////////////////
4457   // Mounting Block Support Up Trapezoid Vertex
4458   ////////////////////////////////////////////
4459         mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4460         mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4461                                                                                                  - mountingsupportedge[i];
4462         mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4463         mountingblocksupportrapezoidupxvertex[i][1] =
4464                                                                                 mountingblocksupportrapezoidupxvertex[i][0];
4465         mountingblocksupportrapezoidupyvertex[i][1] =
4466                                                                                                mountingblockpieceupyvertex[i][0]
4467                                                                                                  + scalefactor*(mountingblockpieceupyvertex[i][1]
4468                                                                                              - mountingblockpieceupyvertex[i][0]);
4469         mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4470         mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4471         mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4472         mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4473         mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4474         mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4475
4476         mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4477                                                                                                                mountingblocksupportrapezoidupyvertex[i]);
4478         mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4479                                                                                                                         -fgkMountingBlockSupportWidth[0]);
4480         mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4481         snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4482         mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4483                                                                 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4484         mountingblocksupportrapezoidup[i]->SetLineColor(9);
4485   }
4486   ///////////////////////////////////////////////////////////////////
4487   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4488   for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4489   Double_t boxoriginup[fgklayernumber][2][3];
4490   Double_t boxorigindown[fgklayernumber][2][3];
4491   char mountingblocksupportboxdownname[100];
4492   char mountingblocksupportboxupname[100];
4493   TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4494   mountingblocksupportrot->SetAngles(90.,180.,-90);
4495   TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4496   globalrefladdersupportrot->SetAngles(0.,90.,0.);
4497   TGeoHMatrix* laddersupportmatrix[2];
4498   laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4499   laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4500   /////////////////////////////////////////////////////////////
4501   // Creating Mother Volume for Containment
4502   /////////////////////////////////////////////////////////////
4503   Double_t *xmothervertex[fgklayernumber];
4504   Double_t *ymothervertex[fgklayernumber];
4505   for(Int_t i=0; i<fgklayernumber; i++){
4506         xmothervertex[i] = new Double_t[8];
4507         ymothervertex[i] = new Double_t[8];
4508   }
4509   TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4510   TGeoVolume* downmotherladdersupport[fgklayernumber];
4511   TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4512   TGeoVolume* upmotherladdersupport[fgklayernumber];
4513   char upmotheladdersupportname[100];
4514   char downmotheladdersupportname[100];
4515   for(Int_t i=0; i<fgklayernumber; i++){
4516         xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4517                                                     -  mountingsupportedge[i];
4518         ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4519         xmothervertex[i][1] = xmothervertex[i][0];
4520         ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4521                                                         + fgkMountingBlockSupportWidth[0];
4522         xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4523         ymothervertex[i][2] = ymothervertex[i][1];
4524         xmothervertex[i][3] = xmothervertex[i][2];
4525         ymothervertex[i][3] = -ymothervertex[i][0];
4526         xmothervertex[i][4] = -xmothervertex[i][0];
4527         ymothervertex[i][4] = ymothervertex[i][3];
4528         xmothervertex[i][5] = xmothervertex[i][4];
4529         ymothervertex[i][5] = -ymothervertex[i][1];
4530         xmothervertex[i][6] = -xmothervertex[i][2];
4531         ymothervertex[i][6] = ymothervertex[i][5];
4532         xmothervertex[i][7] = xmothervertex[i][6];
4533         ymothervertex[i][7] = ymothervertex[i][0];
4534
4535         snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4536         snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
4537
4538         downmotherladdersupportshape[i] = new TGeoXtru(2);
4539         downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4540         downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4541         downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4542                                                                    +                       fgkMountingBlockSupportDownHeight
4543                                                                    +                       fgkSSDMountingBlockHeight[1]
4544                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4545                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4546                                                        - fgkSSDLadderVerticalDisalignment);
4547
4548 //                                                 - fgkSSDModuleVerticalDisalignment);
4549         //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4550
4551         downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4552                                                                           downmotherladdersupportshape[i],fSSDAir);
4553     upmotherladdersupportshape[i] = new TGeoXtru(2);
4554         upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4555         upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4556     upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4557                                                                    +                       fgkMountingBlockSupportUpHeight[i]
4558                                                                    +                       fgkSSDMountingBlockHeight[1]
4559                                                                    -                       0.5*fgkCoolingTubeSupportHeight
4560                                                                    -                       fgkSSDModuleCoolingBlockToSensor
4561                                                  - fgkSSDLadderVerticalDisalignment);
4562
4563      upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4564                                                                                           upmotherladdersupportshape[i],fSSDAir);
4565   }
4566   for(Int_t i=0; i<fgklayernumber; i++){
4567         /////////////////////////
4568         // Setting the box origin
4569         /////////////////////////
4570         boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4571         boxorigindown[i][0][1] =  fgkMountingBlockSupportRadius[i]
4572                                                    +  0.5*fgkMountingBlockSupportDownHeight
4573                                   - 0.5*fgkSSDLadderVerticalDisalignment;
4574         boxorigindown[i][0][2] =  fgkMountingBlockSupportWidth[1]
4575                                                    -  0.5*fgkMountingBlockSupportWidth[0];
4576
4577         boxorigindown[i][1][0] = 0.0;
4578         boxorigindown[i][1][1] = boxorigindown[i][0][1];
4579         boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4580                                                    -      fgkMountingBlockSupportWidth[0]);
4581
4582         boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4583         boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4584                                + 0.5*fgkMountingBlockSupportUpHeight[i]
4585                                - 0.5*fgkSSDLadderVerticalDisalignment;
4586         boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4587                                                  - 0.5*fgkMountingBlockSupportWidth[0];
4588
4589         boxoriginup[i][1][0] = 0.0;
4590         boxoriginup[i][1][1] = boxoriginup[i][0][1];
4591         boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4592                                                  - fgkMountingBlockSupportWidth[0]);
4593
4594         /////////////////////////
4595     // Setting the boxes
4596         /////////////////////////
4597         mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4598                                                                                  +  fgkSSDMountingBlockLength[0]),
4599                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4600                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4601                                                                                         boxorigindown[i][0]);
4602         mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4603                                                                                         0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4604                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4605                                                                                  -  fgkMountingBlockSupportWidth[0]),
4606                                                                                         boxorigindown[i][1]);
4607
4608         mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4609                                                                                  +  fgkSSDMountingBlockLength[0]),
4610                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4611                                                                                         0.5*fgkMountingBlockSupportWidth[0],
4612                                                                                         boxoriginup[i][0]);
4613
4614         mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4615                                                                                         0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4616                                                                                         0.5*(fgkMountingBlockSupportWidth[1]
4617                                                                      -  fgkMountingBlockSupportWidth[0]),
4618                                                                                         boxoriginup[i][1]);
4619         ///////////////////////////////////////
4620         // Adding the Volumes to Mother Volume
4621         ///////////////////////////////////////
4622         for(Int_t j=0; j<2; j++){
4623           snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4624           snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4625           mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4626                                                              mountingblocksupportboxdownshape[i][j],
4627                                                              fSSDCarbonFiberMedium);
4628           mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4629                                                            mountingblocksupportboxupshape[i][j],
4630                                                            fSSDCarbonFiberMedium);
4631                 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4632                 mountingblocksupportboxup[i][j]->SetLineColor(9);
4633                 for(Int_t k=0; k<2; k++){
4634                         downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4635                         upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4636                 }
4637         }
4638         for(Int_t k=0; k<2; k++){
4639                 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4640                 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4641                 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4642                 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4643                 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4644                 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4645                 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4646                 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4647                 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4648                 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4649                 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4650                 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4651         }
4652   }
4653   TList* laddersupportlist = new TList();
4654   laddersupportlist->Add(downmotherladdersupport[0]);
4655   laddersupportlist->Add(upmotherladdersupport[0]);
4656   laddersupportlist->Add(downmotherladdersupport[1]);
4657   laddersupportlist->Add(upmotherladdersupport[1]);
4658   /////////////////////////////////////////////////////////////
4659   // Deallocating memory
4660   /////////////////////////////////////////////////////////////
4661   for(Int_t i=0; i<fgklayernumber; i++){
4662         for(Int_t j=0; j<nedges+1; j++)
4663                 delete vertex[i][j];
4664         delete mountingsupportedgevector[i];
4665         delete [] vertex[i];
4666         delete vertexlist[i];
4667         delete [] xsidevertex[i];
4668         delete [] ysidevertex[i];
4669         delete [] xcentervertex[i];
4670         delete [] ycentervertex[i];
4671         delete [] xsidelowervertex[i];
4672         delete [] ysidelowervertex[i];
4673         delete [] xcenterlowervertex[i];
4674         delete [] ycenterlowervertex[i];
4675         delete [] xmothervertex[i];
4676         delete [] ymothervertex[i];
4677   }
4678   delete [] xsidevertex;
4679   delete [] ysidevertex;
4680   delete [] xcentervertex;
4681   delete [] ycentervertex;
4682   delete [] xsidelowervertex;
4683   delete [] ysidelowervertex;
4684   delete [] xcenterlowervertex;
4685   delete [] ycenterlowervertex;
4686   delete globalrefladdersupportrot;
4687   delete mountingblocksupportrot;
4688   /////////////////////
4689   return laddersupportlist;
4690 }
4691  ////////////////////////////////////////////////////////////////////////////////
4692 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4693 //////////////////////////////////////////
4694 // Method Generating Ladder Support Ring
4695 //////////////////////////////////////////
4696   if(!fCreateMaterials) CreateMaterials();
4697   if(!fTransformationMatrices) CreateTransformationMatrices();
4698   if(!fBasicObjects) CreateBasicObjects();
4699   fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4700   fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4701     const Int_t kssdlayladdernumber[fgklayernumber] =
4702                         {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4703   Double_t mountingsupportedge[fgklayernumber];
4704   Double_t mountingblockratio[fgklayernumber];
4705   Double_t theta[fgklayernumber];
4706   Double_t phi[fgklayernumber];
4707   for(Int_t i=0; i<fgklayernumber; i++){
4708         mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4709     mountingsupportedge[i]    = 0.5*fgkMountingBlockSupportRadius[i]
4710                                                           *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4711                                                           * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4712                                                           - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4713                                                           / kssdlayladdernumber[i])));
4714     theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4715                          / fgkMountingBlockSupportRadius[i]);
4716     phi[i]   = TMath::ASin(0.5*mountingblockratio[i]);
4717   }
4718   TGeoRotation* globalrot = new TGeoRotation();
4719   globalrot->SetAngles(0.,-90.,0.);
4720   TGeoRotation** laddersupportrot[fgklayernumber];
4721   TGeoHMatrix**  laddersupportmatrix[fgklayernumber];
4722   for(Int_t i=0; i<fgklayernumber; i++){
4723         laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4724         laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4725         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4726                 laddersupportrot[i][j] = new TGeoRotation();
4727                 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4728                 switch(i){
4729                         case 0: //Ladder of Layer5
4730                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4731                                 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4732                                                                             laddersupportmatrix[i][j]);
4733                         break;
4734                         case 1: //Ladder of Layer6
4735                                 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4736                                 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4737                                                                               laddersupportmatrix[i][j]);
4738                         break;
4739                 }
4740     }
4741   }
4742   /////////////////////////////////////////////////////////////
4743   // Creating Lower Ladder Support
4744   /////////////////////////////////////////////////////////////
4745   TVector3** ringsupportvertex[fgklayernumber];
4746   Double_t angle = 360./nedges;
4747   for(Int_t i=0; i<fgklayernumber; i++){
4748     ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4749         ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4750                                            * TMath::Cos(theta[i]), 0);
4751         ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4752                                                         -                          mountingsupportedge[i],
4753                                                ringsupportvertex[i][0]->Y(), 0);
4754         ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4755                                                ringsupportvertex[i][1]->Y(),0);
4756     ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4757         for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4758            ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4759            ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4760            ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4761            ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4762         }
4763         ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4764     for(Int_t j=0; j<nedges+1; j++){
4765                 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4766                         new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4767                                (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle), 0);
4768         }
4769   }
4770   Double_t **xmothervertex = new Double_t*[fgklayernumber];
4771   Double_t **ymothervertex = new Double_t*[fgklayernumber];
4772   for(Int_t i=0; i<fgklayernumber; i++){
4773         xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4774         ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4775         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4776                 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4777                 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4778         }
4779   }
4780 ////////////////////////////////////////////////////////////////////////////////
4781 // Start Corrections 13/06/08
4782 ////////////////////////////////////////////////////////////////////////////////
4783   char lowerladderpconsupportname[100];
4784   TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4785   TGeoVolume* lowerladderpconsupport[fgklayernumber];
4786   Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4787   Double_t lowerladderpconradiusmax[fgklayernumber];
4788   Double_t lowerladderpconradiusmin[fgklayernumber];
4789   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4790   lowerladdersupportrot->SetAngles(90.,180.,-90);
4791   for(Int_t i=0; i<fgklayernumber; i++){
4792         lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4793                                                                 *                          TMath::Cos(theta[i]);
4794     lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
4795   }
4796   for(Int_t i=0; i<fgklayernumber; i++){
4797 ///////////////////////////  Modified Version ?///////////////////
4798     lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4799         for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4800                                                          lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4801                                                          lowerladderpconradiusmax[i]);
4802         snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
4803         lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4804     lowerladderpconsupport[i]->SetLineColor(fColorAl);
4805         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4806         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4807  }
4808 ////////////////////////////////////////////////////////////////////////////////
4809 // End Corrections 13/06/08
4810 ////////////////////////////////////////////////////////////////////////////////
4811   /*char lowerladdersupportname[30];
4812   TGeoXtru* lowerladdersupportshape[fgklayernumber];
4813   TGeoVolume* lowerladdersupport[fgklayernumber];
4814   TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4815   lowerladdersupportrot->SetAngles(90.,180.,-90);
4816   for(Int_t i=0; i<fgklayernumber; i++){
4817         lowerladdersupportshape[i] = new TGeoXtru(2);
4818         lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4819                                                                                           xmothervertex[i],ymothervertex[i]);
4820         lowerladdersupportshape[i]->DefineSection(0,0.);
4821     lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4822         sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4823     lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4824                                                         lowerladdersupportshape[i],fSSDSupportRingAl);
4825         lowerladdersupport[i]->SetLineColor(fColorAl);
4826         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4827         (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
4828   }*/
4829   /////////////////////////////////////////////////////////////
4830   // Deallocating memory
4831   /////////////////////////////////////////////////////////////
4832   for(Int_t i=0; i<fgklayernumber; i++){
4833         for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4834                 delete ringsupportvertex[i][j];
4835         delete [] ringsupportvertex[i];
4836   }
4837   for(Int_t i=0; i<fgklayernumber; i++){
4838         delete [] xmothervertex[i];
4839         delete [] ymothervertex[i];
4840   }
4841   delete [] xmothervertex;
4842   delete [] ymothervertex;
4843   delete globalrot;
4844   for(Int_t i=0; i<fgklayernumber; i++){
4845         for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4846                 delete laddersupportrot[i][j];
4847         delete [] laddersupportrot[i];
4848   }
4849  }
4850  ////////////////////////////////////////////////////////////////////////////////
4851  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4852   /////////////////////////////////////////////////////////////
4853   // Method generating Endcap CoverPlate
4854   /////////////////////////////////////////////////////////////
4855   // Holes Definition
4856   ///////////////////
4857   Int_t nendcapcoverplateholedges = 30;
4858   const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4859   Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4860                                                           0.5*fgkEndCapCoverPlateThickness};
4861   TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
4862                                                                                                               nendcapcoverplateholedges,holesection);
4863   TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
4864                                                                                   endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
4865   endcapcoverplatesmallhole->SetLineColor(6);
4866   TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
4867                                                                                                               nendcapcoverplateholedges,holesection);
4868   TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
4869                                                                                   endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
4870   endcapcoverplatebighole->SetLineColor(6);
4871   //////////////////////////
4872   // Screw Piece Definition
4873   //////////////////////////
4874   Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4875   TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4876                                                                                                       CosD(0.5*smallscrewangle),
4877                                                                                                       0.5*fgkEndCapCoverPlateThickness);
4878   TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4879                                                                                                 endcapsmallscrewpieceshape,
4880                                                                                                 fSSDCoolingTubePhynox);
4881   endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4882   ///////////////////
4883   // Box Definition
4884   ///////////////////
4885   TGeoBBox* endcapcoverplateboxshape[4];
4886   TGeoVolume* endcapcoverplatebox[4];
4887   Double_t boxorigin[5][3];
4888   boxorigin[0][0] = 0.;
4889   boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4890   boxorigin[0][2] = 0.;
4891
4892   boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4893   boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4894   boxorigin[1][2] = 0.;
4895
4896   boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4897                                   + fgkEndCapCoverPlateSmallHoleSeparation[1];
4898   boxorigin[2][1] = boxorigin[1][1];
4899   boxorigin[2][2] = 0.;
4900
4901   boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4902                                   + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4903   boxorigin[3][1] = boxorigin[1][1];
4904   boxorigin[3][2] = 0.;
4905
4906   endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4907                                                                                 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4908                                                  -              2.*fgkEndCapCoverPlateSmallHoleRadius),
4909                                                                             0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4910
4911   endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4912                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4913                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4914                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4915                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4916
4917   endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4918                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4919                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4920                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4921                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4922
4923   endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4924                                                                         -2.*fgkEndCapCoverPlateSmallHoleRadius),
4925                                                                                      4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4926                                                           +                              fgkEndCapCoverPlateSmallHoleRadius,
4927                                                                                  0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4928
4929   endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
4930                                                                            fSSDAlCoolBlockMedium);
4931   endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
4932                                                                            fSSDAlCoolBlockMedium);
4933   endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
4934                                                                            fSSDAlCoolBlockMedium);
4935   endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
4936                                                                            fSSDAlCoolBlockMedium);
4937   endcapcoverplatebox[0]->SetLineColor(6);
4938   endcapcoverplatebox[1]->SetLineColor(6);
4939   endcapcoverplatebox[2]->SetLineColor(6);
4940   endcapcoverplatebox[3]->SetLineColor(6);
4941   Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4942   TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4943                                                                                         fgkEndCapCoverPlateSmallHoleRadius,
4944                                                                                         0.5*fgkEndCapCoverPlateThickness,
4945                                                                                         endcapfillingboxorigin);
4946   TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
4947                                                                            fSSDAlCoolBlockMedium);
4948   endcapfillingbox->SetLineColor(6);
4949   ////////////////////////////
4950   // Contour shape Definition
4951   ////////////////////////////
4952   const Int_t kcontourvertexnumber = 10;
4953   Double_t xcontourvertex[kcontourvertexnumber];
4954   Double_t ycontourvertex[kcontourvertexnumber];
4955   xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4956   xcontourvertex[1] = xcontourvertex[0];
4957   xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4958   xcontourvertex[3] = xcontourvertex[2];
4959   xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4960   xcontourvertex[5] = xcontourvertex[4];
4961   xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4962   xcontourvertex[7] = xcontourvertex[6];
4963   xcontourvertex[8] = xcontourvertex[4];
4964   xcontourvertex[9] = xcontourvertex[8];
4965   ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4966                                         - (kendcapcoverplatesmallholenumber[1]-1)
4967                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4968   ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4969                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4970   ycontourvertex[2] = ycontourvertex[1];
4971   ycontourvertex[3] = ycontourvertex[0];
4972   ycontourvertex[4] = ycontourvertex[3];
4973   ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4974   ycontourvertex[6] = ycontourvertex[5];
4975   ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4976                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
4977                                         + fgkEndCapCoverPlateSmallHoleRadius;
4978   ycontourvertex[8] = ycontourvertex[7];
4979   ycontourvertex[9] = ycontourvertex[0];
4980
4981   Double_t xboxin, dxboxin, yboxin, dyboxin;
4982   Double_t xboxout, dxboxout, yboxout, dyboxout;
4983   Double_t coordmin, coordmax;
4984   coordmin = -fgkEndCapCoverPlateLength[0];
4985   coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4986   xboxout = 0.5*(coordmin+coordmax);
4987   dxboxout = 0.5*(coordmax-coordmin);
4988   coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4989                                         - (kendcapcoverplatesmallholenumber[1]-1)
4990                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4991   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4992                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4993   yboxout = 0.5*(coordmin+coordmax);
4994   dyboxout = 0.5*(coordmax-coordmin);
4995   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4996   coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4997   xboxin = 0.5*(coordmin+coordmax);
4998   dxboxin = 0.5*(coordmax-coordmin);
4999   coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5000   coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5001                                         * fgkEndCapCoverPlateSmallHoleSeparation[2]
5002                                         + fgkEndCapCoverPlateSmallHoleRadius;
5003   yboxin = 0.5*(coordmin+coordmax);
5004   dyboxin = 0.5*(coordmax-coordmin);
5005   new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5006   TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5007                                                          xboxout, yboxout, 0.);
5008   trendCapCoverPlateContourboxout->RegisterYourself();
5009   new TGeoBBox("EndCapCoverPlateContourBoxIn",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5010   TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5011                                                          xboxin, yboxin, 0.);
5012   trendCapCoverPlateContourboxin->RegisterYourself();
5013   TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5014         "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5015
5016   TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5017                                                                            fSSDAlCoolBlockMedium);
5018   contour->SetLineColor(6);
5019   /////////////////////////////
5020   // Hole Contour Shape Definition
5021   ////////////////////////////
5022   coordmin = xcontourvertex[0];
5023   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5024   xboxout = 0.5*(coordmin+coordmax);
5025   dxboxout = 0.5*(coordmax-coordmin);
5026   coordmin = ycontourvertex[1];
5027   coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5028   yboxout = 0.5*(coordmin+coordmax);
5029   dyboxout = 0.5*(coordmax-coordmin);
5030   coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5031                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5032   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5033   xboxin = 0.5*(coordmin+coordmax);
5034   dxboxin = 0.5*(coordmax-coordmin);
5035   coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5036                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5037   coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5038   yboxin = 0.5*(coordmin+coordmax);
5039   dyboxin = 0.5*(coordmax-coordmin);
5040   new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5041   TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5042                                                          xboxout, yboxout, 0.);
5043   trendCapCoverPlateContourboxout1->RegisterYourself();
5044   new TGeoBBox("EndCapCoverPlateContourBoxIn1",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5045   TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5046                                                          xboxin, yboxin, 0.);
5047   trendCapCoverPlateContourboxin1->RegisterYourself();
5048   TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5049         "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5050
5051
5052   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5053   coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5054   xboxout = 0.5*(coordmin+coordmax);
5055   dxboxout = 0.5*(coordmax-coordmin);
5056   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5057                                                    - fgkEndCapCoverPlateWidth[0]);
5058   coordmax = ycontourvertex[0];
5059   yboxout = 0.5*(coordmin+coordmax);
5060   dyboxout = 0.5*(coordmax-coordmin);
5061   coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5062                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5063   coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5064   xboxin = 0.5*(coordmin+coordmax);
5065   dxboxin = 0.5*(coordmax-coordmin);
5066   coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5067                                                    - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5068                                                    - fgkEndCapCoverPlateWidth[0]
5069                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5070   coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5071   yboxin = 0.5*(coordmin+coordmax);
5072   dyboxin = 0.5*(coordmax-coordmin);
5073   new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5074   TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5075                                                          xboxout, yboxout, 0.);
5076   trendCapCoverPlateContourboxout2->RegisterYourself();
5077   new TGeoBBox("EndCapCoverPlateContourBoxIn2",  dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5078   TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5079                                                          xboxin, yboxin, 0.);
5080   trendCapCoverPlateContourboxin2->RegisterYourself();
5081   TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5082         "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5083
5084 //  const Int_t kholecontourvertexnumber = 10;
5085
5086   Double_t xholecontourvertex[2][kcontourvertexnumber];
5087   Double_t yholecontourvertex[2][kcontourvertexnumber];
5088   xholecontourvertex[0][0] = xcontourvertex[0];
5089   xholecontourvertex[0][1] = xholecontourvertex[0][0];
5090   xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5091   xholecontourvertex[0][3] = xholecontourvertex[0][2];
5092   xholecontourvertex[0][4] = xholecontourvertex[0][0]
5093                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5094                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5095   xholecontourvertex[0][5] = xholecontourvertex[0][4];
5096   xholecontourvertex[0][6] = xholecontourvertex[0][5]
5097                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5098   xholecontourvertex[0][7] = xholecontourvertex[0][6];
5099   xholecontourvertex[0][8] = xholecontourvertex[0][4];
5100   xholecontourvertex[0][9] = xholecontourvertex[0][8];
5101
5102   yholecontourvertex[0][0] = ycontourvertex[1];
5103   yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5104   yholecontourvertex[0][2] = yholecontourvertex[0][1];
5105   yholecontourvertex[0][3] = yholecontourvertex[0][0];
5106   yholecontourvertex[0][4] = yholecontourvertex[0][3];
5107   yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5108                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5109   yholecontourvertex[0][6] = yholecontourvertex[0][5];
5110   yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5111   yholecontourvertex[0][8] = yholecontourvertex[0][7];
5112   yholecontourvertex[0][9] = yholecontourvertex[0][0];
5113
5114   xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5115   xholecontourvertex[1][1] = xholecontourvertex[1][0];
5116   xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5117   xholecontourvertex[1][3] = xholecontourvertex[1][2];
5118   xholecontourvertex[1][4] = xholecontourvertex[1][0]
5119                                                    + 0.5*(fgkEndCapCoverPlateLength[2]
5120                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5121   xholecontourvertex[1][5] = xholecontourvertex[1][4];
5122   xholecontourvertex[1][6] = xholecontourvertex[1][5]
5123                                                    + 2.*fgkEndCapCoverPlateBigHoleRadius;
5124   xholecontourvertex[1][7] = xholecontourvertex[1][6];
5125   xholecontourvertex[1][8] = xholecontourvertex[1][4];
5126   xholecontourvertex[1][9] = xholecontourvertex[1][8];
5127
5128   yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5129                                                    - fgkEndCapCoverPlateWidth[0]);
5130   yholecontourvertex[1][1] = ycontourvertex[0];
5131   yholecontourvertex[1][2] = yholecontourvertex[1][1];
5132   yholecontourvertex[1][3] = yholecontourvertex[1][0];
5133   yholecontourvertex[1][4] = yholecontourvertex[1][3];
5134   yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5135                                                    - fgkEndCapCoverPlateWidth[0]
5136                                                    - 2.*fgkEndCapCoverPlateBigHoleRadius);
5137   yholecontourvertex[1][6] = yholecontourvertex[1][5];
5138   yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5139   yholecontourvertex[1][8] = yholecontourvertex[1][7];
5140   yholecontourvertex[1][9] = yholecontourvertex[1][0];
5141
5142   TGeoVolume* holecontour[2];
5143   holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
5144                                                                   fSSDAlCoolBlockMedium);
5145   holecontour[0]->SetLineColor(6);
5146   holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
5147                                                                   fSSDAlCoolBlockMedium);
5148   holecontour[1]->SetLineColor(6);
5149   TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5150                                                                         +     fgkEndCapCoverPlateLength[2],0.,0.);
5151   TGeoTranslation*  bigholetrans[3];
5152   bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5153                                                                                 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5154   bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5155                                   +                     fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5156                                   -                                             fgkEndCapCoverPlateBigHoleRadius,0.0);
5157   bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5158                                                                                 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5159   /////////////////////////////////
5160   // Mother Volume Xtru Definition
5161   /////////////////////////////////
5162   const Int_t kmothervertexnumber = 12;
5163   Double_t xmothervertex[kmothervertexnumber];
5164   Double_t ymothervertex[kmothervertexnumber];
5165   xmothervertex[0]  = xcontourvertex[0];
5166   xmothervertex[1]  = xmothervertex[0];
5167   xmothervertex[2]  = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5168   xmothervertex[3]  = xmothervertex[2];
5169   xmothervertex[4]  = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5170   xmothervertex[5]  = xmothervertex[4];
5171   xmothervertex[6]  = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5172   xmothervertex[7]  = xmothervertex[6];
5173   xmothervertex[8]  = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5174                                         + fgkEndCapCoverPlateLength[2];
5175   xmothervertex[9]  = xmothervertex[8];
5176   xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5177   xmothervertex[11] = xmothervertex[10];
5178
5179   ymothervertex[0]  = ycontourvertex[0];
5180   ymothervertex[1]  = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5181   ymothervertex[2]  = ymothervertex[1];
5182   ymothervertex[3]  = ycontourvertex[1];
5183   ymothervertex[4]  = ymothervertex[3];
5184   ymothervertex[5]  = ymothervertex[1];
5185   ymothervertex[6]  = ymothervertex[5];
5186   ymothervertex[7]  = ymothervertex[0];
5187   ymothervertex[8]  = ymothervertex[7];
5188   ymothervertex[9]  = ymothervertex[8]
5189                                    - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5190   ymothervertex[10] = ymothervertex[9];
5191   ymothervertex[11] = ymothervertex[8];
5192   TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5193   mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5194   mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5195   mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5196   TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5197   ////////////////////////////////////////
5198   // Adding Nodes
5199   ////////////////////////////////////////
5200 //  TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5201   TGeoTranslation*** endcapcoverplatesmallholetrans;
5202   endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5203   Double_t transx[4] = {0,
5204                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
5205                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
5206                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
5207                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5208                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
5209   Int_t index = 0;
5210   for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5211         endcapcoverplatesmallholetrans[i] =
5212                                         new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5213     for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5214                 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5215             endcapcoverplatesmallholetrans[i][j] =
5216                 new TGeoTranslation(transx[i],
5217                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5218             if(index!=10){
5219                         mothercoverplate->AddNode(endcapcoverplatesmallhole,
5220                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5221                         mothercoverplate->AddNode(endcapsmallscrewpiece,
5222                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5223                 }
5224                 if(j<kendcapcoverplatesmallholenumber[1]-1)
5225                         mothercoverplate->AddNode(endcapcoverplatebox[0],
5226                                                                           index,endcapcoverplatesmallholetrans[i][j]);
5227     }
5228   }
5229   mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5230   mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5231   mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5232   mothercoverplate->AddNode(endcapfillingbox,1);
5233   mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5234   mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5235   mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5236   mothercoverplate->AddNode(holecontour[0],1);
5237   mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5238   mothercoverplate->AddNode(holecontour[1],1);
5239   mothercoverplate->AddNode(contour,1);
5240
5241   for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5242     delete [] endcapcoverplatesmallholetrans[i];
5243   delete [] endcapcoverplatesmallholetrans;
5244   /////////////////////////////////
5245   return mothercoverplate;
5246  }
5247  ////////////////////////////////////////////////////////////////////////////////
5248  TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5249   /////////////////////////////////////////////////////////////
5250   // Getting EndCap Cooling Tube
5251   /////////////////////////////////////////////////////////////
5252   TGeoTorus* endcapcoolingtubetorushape[5];
5253   TGeoVolume* endcapcoolingtubetorus[5];
5254   TGeoTube* endcapcoolingtubeshape[4];
5255   TGeoVolume* endcapcoolingtube[4];
5256   char endcapcoolingtubetorusname[100];
5257   char endcapcoolingtubename[100];
5258   TGeoTorus* endcapcoolingwatertubetorushape[5];
5259   TGeoVolume* endcapcoolingwatertubetorus[5];
5260   TGeoTube* endcapcoolingwatertubeshape[4];
5261   TGeoVolume* endcapcoolingwatertube[4];
5262   char endcapcoolingwatertubetorusname[100];
5263   char endcapcoolingwatertubename[100];
5264   for(Int_t i=0; i<5; i++){
5265     snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5266     snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5267     snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5268     snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5269     if(i==3){
5270       endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5271                                                     fgkEndCapCoolingTubeRadiusMin,
5272                                                     fgkEndCapCoolingTubeRadiusMax,
5273                                                     90.0,fgkEndCapCoolingTubeAngle[3]);
5274       endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5275                                                          0.,fgkEndCapCoolingTubeRadiusMin,
5276                                                          90.0,fgkEndCapCoolingTubeAngle[3]);
5277     }
5278     else{
5279       endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5280                                                     :fgkEndCapCoolingTubeAxialRadius[1],
5281                                                     fgkEndCapCoolingTubeRadiusMin,
5282                                                     fgkEndCapCoolingTubeRadiusMax,
5283                                                     0.,fgkEndCapCoolingTubeAngle[i]);
5284       endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5285                                                          :fgkEndCapCoolingTubeAxialRadius[1],
5286                                                          0.,fgkEndCapCoolingTubeRadiusMin,
5287                                                          0.,fgkEndCapCoolingTubeAngle[i]);
5288     }
5289         endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5290                                                                                            endcapcoolingtubetorushape[i],
5291                                                                                            fSSDCoolingTubePhynox);
5292         endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5293                                                                                                         endcapcoolingwatertubetorushape[i],
5294                                                                                                         fSSDCoolingTubeWater);
5295     endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5296     endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5297     if(i<4){
5298                 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5299                                                                   fgkEndCapCoolingTubeRadiusMax,
5300                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5301                 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5302                                                           0.5*fgkEndCapCoolingTubeLength[i]);
5303         endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5304                                                          endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5305         endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5306                                                          endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5307                 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5308                 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5309         }
5310   }
5311   TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5312   /////////////////////////////////////////
5313   // Transformation for Volume Positioning
5314   /////////////////////////////////////////
5315   TGeoCombiTrans* coolingtubecombitrans[6];
5316   TGeoRotation* coolingtuberot[8];
5317   TGeoTranslation* coolingtubetrans[6];
5318   TGeoHMatrix* coolingtubematrix[4];
5319   TGeoCombiTrans* torustubecombitrans[4];
5320   TGeoRotation* torustuberot[7];
5321   TGeoTranslation* torustubetrans[4];
5322   TGeoHMatrix* torustubematrix[5];
5323   TGeoCombiTrans* coolingwatertubecombitrans[6];
5324   TGeoRotation* coolingwatertuberot[8];
5325   TGeoTranslation* coolingwatertubetrans[6];
5326   TGeoHMatrix* coolingwatertubematrix[4];
5327   TGeoCombiTrans* toruswatertubecombitrans[4];
5328   TGeoRotation* toruswatertuberot[7];
5329   TGeoTranslation* toruswatertubetrans[4];
5330   TGeoHMatrix* toruswatertubematrix[5];
5331   for(Int_t i=0; i<8; i++){
5332     if(i<6){
5333          coolingtubetrans[i] = new TGeoTranslation();
5334          coolingwatertubetrans[i] = new TGeoTranslation();
5335     }
5336     if(i<8){
5337          coolingtuberot[i] = new TGeoRotation();
5338          coolingwatertuberot[i] = new TGeoRotation();
5339     }
5340     if(i<4){
5341          torustubetrans[i] = new TGeoTranslation();
5342          toruswatertubetrans[i] = new TGeoTranslation();
5343     }
5344     if(i<7){
5345          torustuberot[i] = new TGeoRotation();
5346          toruswatertuberot[i] = new TGeoRotation();
5347         }
5348   }
5349   /////////////////////////////////////////
5350   // Transformation for Inox Volume Positioning
5351   /////////////////////////////////////////
5352   coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5353                                                                           -endcapcoolingtubeshape[0]->GetDz(),0.);
5354   coolingtuberot[0]->SetAngles(0.,90.,0.);
5355   coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5356                                                                                                 *coolingtuberot[0]);
5357
5358   coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5359   coolingtuberot[1]->SetAngles(0.,90.,0.);
5360   coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5361                                                                                                 *coolingtuberot[1]);
5362
5363   coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5364                                                                          *CosD(fgkEndCapCoolingTubeAngle[0]),
5365                                                                           fgkEndCapCoolingTubeAxialRadius[0]
5366                                                                          *SinD(fgkEndCapCoolingTubeAngle[0]),
5367                                                                           0.);
5368   coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5369   coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5370                                                                                                 *coolingtuberot[2]);
5371
5372   coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5373                                            *                             (*coolingtubecombitrans[1]));
5374
5375   torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5376                                                                          endcapcoolingtubeshape[1]->GetDz());
5377   torustuberot[0]->SetAngles(0.,90.,0.);
5378   torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5379
5380   torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5381
5382   coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5383                                                                           -endcapcoolingtubeshape[2]->GetDz(),0.);
5384   coolingtuberot[3]->SetAngles(0.,90.,0.);
5385   coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5386                                                                                                 *coolingtuberot[3]);
5387   coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5388   coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5389   coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5390
5391   torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5392                                                                         endcapcoolingtubeshape[2]->GetDz());
5393   torustuberot[1]->SetAngles(0.,90.,0.);
5394   torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5395   torustuberot[2]->SetAngles(180.,0.,0.);
5396   torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5397   torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5398
5399   torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5400                                                                         -fgkEndCapCoolingTubeAxialRadius[0]);
5401   torustuberot[3]->SetAngles(0.,90.,0.);
5402   torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5403   torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5404   torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5405   torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5406
5407   coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5408                                                                           fgkEndCapCoolingTubeAxialRadius[0],0.);
5409   coolingtuberot[5]->SetAngles(90.,90.,-90.);
5410   coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5411                                                                                                 *coolingtuberot[5]);
5412   coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5413   coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5414   coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5415
5416   torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5417                                                                         endcapcoolingtubeshape[0]->GetDz());
5418   torustuberot[5]->SetAngles(0.,90.,0.);
5419   torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5420   torustuberot[6]->SetAngles(-90.,0.,0.);
5421   torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5422   torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5423
5424   coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5425                                                                           endcapcoolingtubeshape[3]->GetDz(),0.);
5426   coolingtuberot[6]->SetAngles(0.,90.,0.);
5427   coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5428                                                                                                 *coolingtuberot[6]);
5429   coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5430   coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5431   coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5432     /////////////////////////////////////////
5433   // Transformation for Water Volume Positioning
5434   /////////////////////////////////////////
5435   coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5436                                                                           -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5437   coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5438   coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5439                                                                                                      *coolingwatertuberot[0]);
5440
5441   coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5442   coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5443   coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5444                                                                                                      *coolingwatertuberot[1]);
5445
5446   coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5447                                                                                   *CosD(fgkEndCapCoolingTubeAngle[0]),
5448                                                                                   fgkEndCapCoolingTubeAxialRadius[0]
5449                                                                                   *SinD(fgkEndCapCoolingTubeAngle[0]),
5450                                                                               0.);
5451   coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5452   coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5453                                                                                                     *coolingwatertuberot[2]);
5454
5455   coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5456                                            *                                 (*coolingwatertubecombitrans[1]));
5457
5458   toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5459                                                                          endcapcoolingwatertubeshape[1]->GetDz());
5460   toruswatertuberot[0]->SetAngles(0.,90.,0.);
5461   toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5462                                                                                                    *toruswatertuberot[0]);
5463
5464   toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5465                                                   *                                     (*toruswatertubecombitrans[0]));
5466
5467   coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5468                                                                           -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5469   coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5470   coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5471                                                                                                      *coolingwatertuberot[3]);
5472   coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5473   coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5474                                                         *                                 (*coolingwatertubecombitrans[3]));
5475   coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5476
5477   toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5478                                                                         endcapcoolingwatertubeshape[2]->GetDz());
5479   toruswatertuberot[1]->SetAngles(0.,90.,0.);
5480   toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5481                                                                                                    *toruswatertuberot[1]);
5482   toruswatertuberot[2]->SetAngles(180.,0.,0.);
5483   toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5484                                                   *                 (*toruswatertubecombitrans[1]));
5485   toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5486
5487   toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5488                                                                                    -fgkEndCapCoolingTubeAxialRadius[0]);
5489   toruswatertuberot[3]->SetAngles(0.,90.,0.);
5490   toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5491                                                                                                    *toruswatertuberot[3]);
5492   toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5493   toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5494                                                   *                                     (*toruswatertubecombitrans[2]));
5495   toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5496
5497   coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5498                                                                                 fgkEndCapCoolingTubeAxialRadius[0],0.);
5499   coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5500   coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5501                                                                                                      *coolingwatertuberot[5]);
5502   coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5503   coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5504                                                         *                                 (*coolingwatertubecombitrans[4]));
5505   coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5506
5507   toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5508                                                                               endcapcoolingwatertubeshape[0]->GetDz());
5509   toruswatertuberot[5]->SetAngles(0.,90.,0.);
5510   toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5511                                                                                                    *toruswatertuberot[5]);
5512   toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5513   toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5514                                                   *                 (*toruswatertubecombitrans[3]));
5515   toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5516
5517   coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5518                                                                           endcapcoolingwatertubeshape[3]->GetDz(),0.);
5519   coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5520   coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5521                                                                                                      *coolingwatertuberot[6]);
5522   coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5523   coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5524                                                         *                                 (*coolingwatertubecombitrans[5]));
5525   coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5526   /////////////////////////////////////////
5527   // Positioning Volumes
5528   /////////////////////////////////////////
5529   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5530   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5531
5532   endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5533   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5534
5535   endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5536   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5537
5538   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5539   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5540
5541   endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5542   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5543
5544   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5545   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5546
5547   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5548   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5549
5550   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5551   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5552
5553   endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5554   endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5555
5556   endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5557   endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5558   /////////////////////////////////////////////////////////////
5559   // Deallocating memory
5560   /////////////////////////////////////////////////////////////
5561   for(Int_t i=0; i<8; i++){
5562     if(i<6){
5563          delete coolingtubetrans[i];
5564          delete coolingwatertubetrans[i];
5565          if(i!=0){
5566           delete coolingtubecombitrans[i];
5567           delete coolingwatertubecombitrans[i];
5568          }
5569         }
5570     if(i<8){
5571           delete coolingtuberot[i];
5572           delete coolingwatertuberot[i];
5573     }
5574     if(i<4){
5575                 delete torustubetrans[i];
5576                 delete toruswatertubetrans[i];
5577                 delete torustubecombitrans[i];
5578                 delete toruswatertubecombitrans[i];
5579         }
5580     if(i<7){
5581          delete torustuberot[i];
5582          delete toruswatertuberot[i];
5583         }
5584   }
5585   /////////////////////////////////////////////////////////////
5586   return endcapcoolingtubemother;
5587  }
5588  ////////////////////////////////////////////////////////////////////////////////
5589  TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5590   /////////////////////////////////////////////////////////////
5591   // Getting EndCap Cover Side
5592   /////////////////////////////////////////////////////////////
5593   const Int_t kendcapcoverholenumber[2] = {7,5};
5594   const Int_t kvertexnumber = 15;
5595   Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5596   xvertex[0]  = 0.0;
5597   xvertex[1]  = xvertex[0];
5598   xvertex[2]  = fgkEndCapSideCoverLength[0];
5599   xvertex[3]  = fgkEndCapSideCoverLength[1];
5600   xvertex[4]  = xvertex[3];
5601   xvertex[5]  = fgkEndCapSideCoverLength[2];
5602   xvertex[6]  = xvertex[5];
5603   xvertex[7]  = xvertex[2];
5604   xvertex[8]  = xvertex[7];
5605   xvertex[9]  = xvertex[6]-fgkEndCapSideCoverLength[0];
5606   xvertex[10] = xvertex[9];
5607   xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5608                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5609                           * fgkEndCapSideCoverLength[4];
5610   xvertex[12] = xvertex[11];
5611   xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5612                           * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5613                           * fgkEndCapSideCoverLength[4];
5614   xvertex[14] = xvertex[13];
5615   yvertex[0]  = 0.0;
5616   yvertex[1]  = fgkEndCapSideCoverWidth[0];
5617   yvertex[2]  = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5618   yvertex[3]  = yvertex[2];
5619   yvertex[4]  = fgkEndCapSideCoverWidth[1];
5620   yvertex[5]  = yvertex[4];
5621   yvertex[6]  = yvertex[0];
5622   yvertex[7]  = yvertex[6];
5623   yvertex[8]  = fgkEndCapSideCoverWidth[6];
5624   yvertex[9]  = yvertex[8];
5625   yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5626   yvertex[11] = yvertex[10];
5627   yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5628   yvertex[13] = yvertex[12];
5629   yvertex[14] = yvertex[6];
5630   TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5631   endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5632   endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5633   endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5634   endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5635   TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5636   endcapsidecovershapein->SetName("endcapsidecovershapein");
5637   endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5638   endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5639   endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5640
5641
5642   TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
5643   TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5644                                                                 endcapsidecovershape,fSSDCoolingTubePhynox);
5645   endcapsidecover->SetLineColor(fColorPhynox);
5646   ////////////////////////////////////////////
5647   // Defininition of Mother Volume
5648   ////////////////////////////////////////////
5649   const Int_t kmothervertexnumber = 7;
5650   Double_t xmothervertex[kmothervertexnumber];
5651   Double_t ymothervertex[kmothervertexnumber];
5652   for(Int_t i=0; i<kmothervertexnumber; i++){
5653         xmothervertex[i] = xvertex[i];
5654         ymothervertex[i] = yvertex[i];
5655   }
5656   TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5657   endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5658   endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5659   endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5660   TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5661                                                                 endcapsidecovermothershape,fSSDAir);
5662   ////////////////////////////////////////////
5663   endcapsidecovermother->AddNode(endcapsidecover,1);
5664   TGeoBBox* endcapsidecoverboxshape[4];
5665   endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5666                                                          +     (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5667                                                                0.5*fgkEndCapSideCoverLength[4],
5668                                                                    0.5*fgkEndCapSideCoverThickness);
5669   endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5670                                                          +     (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5671                                                                0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5672                                                          -     fgkEndCapSideCoverLength[4]),
5673                                                                    0.5*fgkEndCapSideCoverThickness);
5674   endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5675                                                                0.5*fgkEndCapSideCoverLength[4],
5676                                                                    0.5*fgkEndCapSideCoverThickness);
5677   endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5678                                                                0.5*fgkEndCapSideCoverWidth[5],
5679                                                                    0.5*fgkEndCapSideCoverThickness);
5680   TGeoVolume* endcapsidecoverbox[4];
5681   endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5682   endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5683   endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5684   endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5685   for(Int_t i=0; i<4; i++)   endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5686 //  TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5687   TGeoTranslation** endcapsidecoverboxtrans;
5688   endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5689   endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5690                                                          +                                         fgkEndCapSideCoverLength[0],
5691                                                                                                    endcapsidecoverboxshape[0]->GetDY()
5692                                                          +                     yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5693   endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5694                                                          +                     xvertex[11],
5695                                                                                                    endcapsidecoverboxshape[1]->GetDY()
5696                                                          +                     yvertex[12],0.);
5697   endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5698                                                          +                     xvertex[11],
5699                                                                                                    endcapsidecoverboxshape[2]->GetDY()
5700                                                          +                     yvertex[12]
5701                                                          +                                         2.*endcapsidecoverboxshape[1]->GetDY()
5702                                                          +                     fgkEndCapSideCoverWidth[5],0.);
5703   endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5704   endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5705   endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5706   for(Int_t i=0; i<2; i++)
5707         for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5708                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5709                         new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5710                                                                 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5711                                                                 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5712                                                                 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5713                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5714                                                                 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5715         }
5716   for(Int_t i=0; i<2; i++)
5717         for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5718                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5719                 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5720                                                         +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5721                                                         endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5722                                                         +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5723                                                         +fgkEndCapSideCoverLength[4]),0.0);
5724                 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5725                                                                 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5726                                                                 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5727                                                                 +i*(kendcapcoverholenumber[1]-1)+j]);
5728         }
5729   delete [] endcapsidecoverboxtrans;
5730   return endcapsidecovermother;
5731  }
5732  ////////////////////////////////////////////////////////////////////////////////
5733  TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5734  ////////////////////////////////////////////////////////////////////////////////
5735  // Method returning Interface Card A, Interface Card B, Supply Card
5736  ////////////////////////////////////////////////////////////////////////////////
5737  /////////////////////
5738  // Supply Card
5739  /////////////////////
5740  // Electronic Board Back Al Plane
5741  const Int_t kelectboardbackvertexnumber = 8;
5742  Double_t xelectboardback[kelectboardbackvertexnumber];
5743  Double_t yelectboardback[kelectboardbackvertexnumber];
5744  xelectboardback[0] = 0.0;
5745  xelectboardback[1] = xelectboardback[0];
5746  xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5747  xelectboardback[3] = xelectboardback[2];
5748  xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5749  xelectboardback[5] = xelectboardback[4];
5750  xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5751  xelectboardback[7] = xelectboardback[6];
5752
5753  yelectboardback[0] = 0.0;
5754  yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5755  yelectboardback[2] = yelectboardback[1];
5756  yelectboardback[3] = yelectboardback[0];
5757  yelectboardback[4] = yelectboardback[3];
5758  yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5759  yelectboardback[6] = yelectboardback[5];
5760  yelectboardback[7] = yelectboardback[4];
5761  TGeoXtru* electboardbackshape = new TGeoXtru(2);
5762  electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5763                                                                         xelectboardback,yelectboardback);
5764  electboardbackshape->DefineSection(0,0.0);
5765  electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5766  TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5767                                                                                          electboardbackshape,fSSDSupportRingAl);
5768  electboardback->SetLineColor(fColorAl);
5769  // Electronic Board Kapton Layer
5770  const Int_t kelectlayervertexnumber = 8;
5771  Double_t xelectlayer[kelectlayervertexnumber];
5772  Double_t yelectlayer[kelectlayervertexnumber];
5773  xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5774  xelectlayer[1] = xelectlayer[0];
5775  xelectlayer[2] = fgkEndCapCardElectBoardLength;
5776  xelectlayer[3] = xelectlayer[2];
5777  for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5778
5779  yelectlayer[0] = 0.0;
5780  yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5781  yelectlayer[2] = yelectlayer[1];
5782  yelectlayer[3] = yelectlayer[0];
5783  yelectlayer[4] = yelectlayer[3];
5784  yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5785  yelectlayer[6] = yelectlayer[5];
5786  yelectlayer[7] = yelectlayer[4];
5787  TGeoXtru* electlayershape = new TGeoXtru(2);
5788  electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5789  electlayershape->DefineSection(0,0.0);
5790  electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5791  TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5792                                                                                          electlayershape,fSSDKaptonFlexMedium);
5793  electlayer->SetLineColor(fColorKapton);
5794  // JMD Connector Female
5795  const Int_t kjmdconnectorvertexnumber = 6;
5796  Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5797  Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5798  xjmdconnectorvertex[0] = 0.0;
5799  xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5800  xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5801  xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5802  xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5803  xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5804
5805  yjmdconnectorvertex[0] = 0.0;
5806  yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5807  yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5808  yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5809  yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5810  yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5811  TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5812  jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5813                                                                   yjmdconnectorvertex);
5814  jmdconnectorshape->DefineSection(0,0.0);
5815  jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5816  TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5817                                                                                    jmdconnectorshape,fSSDMountingBlockMedium);
5818  jmdconnector->SetLineColor(fColorG10);
5819  // Top Cable Connector
5820  const Int_t kcableconnectorvertexnumber = 8;
5821  Double_t xconnectorvertex[kcableconnectorvertexnumber];
5822  Double_t yconnectorvertex[kcableconnectorvertexnumber];
5823  xconnectorvertex[0] = 0.0;
5824  xconnectorvertex[1] = xconnectorvertex[0];
5825  xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5826  xconnectorvertex[3] = xconnectorvertex[2];
5827  xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5828                                          - fgkEndCapCardCableConnectorLength[2];
5829  xconnectorvertex[5] = xconnectorvertex[4];
5830  xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5831  xconnectorvertex[7] = xconnectorvertex[6];
5832
5833  yconnectorvertex[0] = 0.0;
5834  yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5835  yconnectorvertex[2] = yconnectorvertex[1];
5836  yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5837  yconnectorvertex[4] = yconnectorvertex[3];
5838  yconnectorvertex[5] = yconnectorvertex[1];
5839  yconnectorvertex[6] = yconnectorvertex[5];
5840  yconnectorvertex[7] = yconnectorvertex[0];
5841  TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5842  cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5843                                                                     yconnectorvertex);
5844  cableconnectorshape->DefineSection(0,0.0);
5845  cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5846  TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5847                                                                                    cableconnectorshape,fSSDMountingBlockMedium);
5848  cableconnector->SetLineColor(fColorG10);
5849  // Strip Connection
5850  TGeoBBox* endcapstripconnectionshape =
5851                                                                 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5852                                                                                          0.5*fgkEndCapStripConnectionThickness,
5853                                                                                          0.5*fgkEndCapStripConnectionWidth);
5854  TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5855                                                                                                         endcapstripconnectionshape,
5856                                                                                                         fSSDSupportRingAl);
5857  endcapstripconnection->SetLineColor(fColorAl);
5858  // Interface Card B
5859  const Int_t kcardBvertexnumber = 12;
5860  Double_t xcardBvertexnumber[kcardBvertexnumber];
5861  Double_t ycardBvertexnumber[kcardBvertexnumber];
5862
5863  xcardBvertexnumber[0]  = 0.0;
5864  xcardBvertexnumber[1]  = xcardBvertexnumber[0];
5865  xcardBvertexnumber[2]  = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5866  xcardBvertexnumber[3]  = xcardBvertexnumber[2];
5867  xcardBvertexnumber[4]  = xcardBvertexnumber[1];
5868  xcardBvertexnumber[5]  = xcardBvertexnumber[4];
5869  xcardBvertexnumber[6]  = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5870  xcardBvertexnumber[7]  = xcardBvertexnumber[6];
5871  xcardBvertexnumber[8]  = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5872  xcardBvertexnumber[9]  = xcardBvertexnumber[8];
5873  xcardBvertexnumber[10] = xcardBvertexnumber[7];
5874  xcardBvertexnumber[11] = xcardBvertexnumber[10];
5875
5876  ycardBvertexnumber[0]  = 0.0;
5877  ycardBvertexnumber[1]  = fgkEndCapInterfaceCardBWidth[0];
5878  ycardBvertexnumber[2]  = ycardBvertexnumber[1];
5879  ycardBvertexnumber[3]  = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5880  ycardBvertexnumber[4]  = ycardBvertexnumber[3];
5881  ycardBvertexnumber[5]  = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5882  ycardBvertexnumber[6]  = ycardBvertexnumber[5];
5883  ycardBvertexnumber[7]  = ycardBvertexnumber[4];
5884  ycardBvertexnumber[8]  = ycardBvertexnumber[7];
5885  ycardBvertexnumber[9]  = ycardBvertexnumber[1];
5886  ycardBvertexnumber[10] = ycardBvertexnumber[9];
5887  ycardBvertexnumber[11] = ycardBvertexnumber[0];
5888
5889  TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5890  interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5891  interfacecardBshape->DefineSection(0,0.);
5892  interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5893  TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5894                                                                                          fSSDMountingBlockMedium);
5895  interfacecardB->SetLineColor(46);
5896  // Interface Card B Electronic Board
5897  const Int_t kelectboardcardBvertexnumber = 14;
5898  Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5899  Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5900
5901  xelectboardcardBvertex[0]  = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5902  xelectboardcardBvertex[1]  = xelectboardcardBvertex[0];
5903  xelectboardcardBvertex[2]  = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5904  xelectboardcardBvertex[3]  = xelectboardcardBvertex[2];
5905  xelectboardcardBvertex[4]  = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5906  xelectboardcardBvertex[5]  = xelectboardcardBvertex[4];
5907  xelectboardcardBvertex[6]  = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5908  xelectboardcardBvertex[7]  = xelectboardcardBvertex[6];
5909  xelectboardcardBvertex[8]  = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5910  xelectboardcardBvertex[9]  = xelectboardcardBvertex[8];
5911  xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5912  xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5913  xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5914  xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5915
5916  yelectboardcardBvertex[0]  = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5917  yelectboardcardBvertex[1]  = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5918  yelectboardcardBvertex[2]  = yelectboardcardBvertex[1];
5919  yelectboardcardBvertex[3]  = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5920  yelectboardcardBvertex[4]  = yelectboardcardBvertex[3];
5921  yelectboardcardBvertex[5]  = yelectboardcardBvertex[2];
5922  yelectboardcardBvertex[6]  = yelectboardcardBvertex[5];
5923  yelectboardcardBvertex[7]  = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5924  yelectboardcardBvertex[8]  = yelectboardcardBvertex[7];
5925  yelectboardcardBvertex[9]  = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5926  yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5927  yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5928  yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5929  yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5930
5931  TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5932  electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5933                                                                          xelectboardcardBvertex,yelectboardcardBvertex);
5934  electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5935  electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5936                                                                          + fgkEndCapInterfaceElectBoardCardBThickness);
5937  TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5938                                                                                           fSSDSupportRingAl);
5939  electboardcardB->SetLineColor(fColorAl);
5940  // Generating Stiffener 2
5941  TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5942                                                                                            0.5*fgkEndCapStiffenerThickness,
5943                                                                                            0.5*fgkEndCapStiffenerLength);
5944  TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5945  endcapstiffener->SetLineColor(fColorAl);
5946  // Generating Mother Interface Card B Container
5947  const Int_t kinterfacecardBmothervertexnumber = 10;
5948  Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5949  Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5950
5951  xinterfacecardBmothervertex[0] = 0.0;
5952  xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5953  xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5954                                                                 + fgkEndCapInterfaceCardBThickness;
5955  xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5956  xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5957                                                                 + fgkEndCapInterfaceElectBoardCardBThickness;
5958  xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5959  xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5960  xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5961  xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5962                                                                 + fgkEndCapCardJMDConnectorLength[0];
5963  xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5964
5965  yinterfacecardBmothervertex[0] = 0.0;
5966  yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5967                                                                 + fgkEndCapInterfaceCardBWidth[1]
5968                                                                 + fgkEndCapInterfaceCardBWidth[2];
5969  yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5970  yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5971  yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5972  yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5973  yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5974  yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5975                                                                 + fgkEndCapCardJMDConnectorWidth[0]
5976                                                                 + fgkEndCapCardJMDConnectorWidth[1];
5977  yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5978  yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5979  TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5980  interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5981                                                                                   xinterfacecardBmothervertex,
5982                                                                                   yinterfacecardBmothervertex);
5983  interfacecardBmothershape->DefineSection(0,-1.e-15);
5984  interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5985  TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5986                                                                                                    interfacecardBmothershape,fSSDAir);
5987  electboardcardB->SetLineColor(fColorAl);
5988  // Positioning Volumes Mother Interface Card B Container
5989  TGeoRotation* interfacecardBrot = new TGeoRotation();
5990  TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5991  interfacecardBrot->SetAngles(90.,-90.,-90.);
5992  interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5993  TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5994  TGeoRotation* electboardcardBrot = new TGeoRotation();
5995  TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5996  electboardcardBrot->SetAngles(90.,90.,-90.);
5997  electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5998  TGeoCombiTrans* electboardcardBcombitrans =
5999                                   new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6000  interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6001  interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6002  TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6003  jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6004  TGeoTranslation* jmdconnectorcardBtrans[3];
6005  TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6006  for(Int_t i=0; i<3; i++){
6007    jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6008                                                          + fgkEndCapCardJMDConnectorLength[0],
6009                                                            fgkEndCapCardElectBoardLayerWidth[1],
6010                                                            0.5*fgkEndCapCardJMDConnectorThickness
6011                                                          + 0.5*(fgkEndCapInterfaceCardBLength[1]
6012                                                          - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6013                                                          + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6014    jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6015                                                                                                            *jmdconnectorcardBrot);
6016    interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6017  }
6018  // Mother Supply Card Container
6019  TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6020  // Interface Card Container
6021  TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6022  // Placing Volumes in Mother Supply Card Container
6023  // JMD Connector Positioning
6024  TGeoTranslation* jmdconnectortrans[2];
6025  for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6026  jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6027                                                                                         fgkEndCapCardElectBoardBackLength[0]
6028                                           -                                             fgkEndCapCardJMDConnectorThickness
6029                                           -                                             fgkEndCapCardJMDConnectorToLayer);
6030  TGeoRotation* jmdconnectorot = new TGeoRotation();
6031  jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6032                                                                  + 2.*fgkEndCapCardJMDConnectorLength[0]
6033                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness,
6034                                                                           fgkEndCapCardElectBoardLayerWidth[1],
6035                                                                       fgkEndCapCardJMDConnectorThickness
6036                                                                  +    fgkEndCapCardJMDConnectorToLayer);
6037  jmdconnectorot->SetAngles(90.,180.,-90);
6038  TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6039                                                                                 * jmdconnectorot);
6040  mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6041  mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6042  // Top Cable Connector Placing
6043  TGeoRotation* cableconnectorot[2];
6044  for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6045  TGeoTranslation* cableconnectortrans[3];
6046  for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6047  cableconnectorot[0]->SetAngles(90.,0.,0.);
6048  cableconnectorot[1]->SetAngles(0.,-90.,0.);
6049  cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6050  TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6051                                                                                                                            *cableconnectorot[0]);
6052  TGeoHMatrix* cableconnectormatrix[2];
6053  for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6054                                                         new TGeoHMatrix((*cableconnectorot[1])
6055                                                                                    *(*cableconnectorcombitrans));
6056  cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6057                                            -                               fgkEndCapCardCableConnectorThickness,
6058                                                                                 fgkEndCapCardCableConnectorLength[0]
6059                                            +                            fgkEndCapCardCableConnectorToLayer);
6060  cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6061                                            -                2.*fgkEndCapCardCableConnectorThickness
6062                                            -                            fgkEndCapCardCableConnectorDistance,
6063                                                                                 fgkEndCapCardCableConnectorLength[0]
6064                                            +                            fgkEndCapCardCableConnectorToLayer);
6065  for(Int_t i=0; i<2; i++){
6066         cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6067     mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6068  }
6069  TGeoRotation* electboardbackrot = new TGeoRotation();
6070  TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6071  electboardbackrot->SetAngles(90.,-90.,-90.);
6072  electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6073                                                         +                fgkEndCapCardJMDConnectorLength[0]
6074                                                         +                fgkEndCapCardElectBoardLayerThickness,0.,0.);
6075  TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6076                                                                                                                            *electboardbackrot);
6077  mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6078  // Electronic Board Kapton Layer Positioning
6079  TGeoRotation* electlayerrot = new TGeoRotation();
6080  TGeoTranslation* electlayertrans[2];
6081  TGeoCombiTrans* electlayercombitrans[2];
6082  for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6083  electlayerrot->SetAngles(90.,-90.,-90.);
6084  electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6085                                                                  + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6086  electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6087                                                                  + 2.*fgkEndCapCardElectBoardLayerThickness
6088                                                                  + fgkEndCapCardElectBoardBackThickness,0.,0.);
6089  for(Int_t i=0; i<2; i++){
6090         electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6091         mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6092  }
6093  // Placing Volumes in Mother Interface Card Container
6094  motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6095  motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6096  for(Int_t i=0; i<2; i++){
6097         motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6098  }
6099  /////////////////////////////////////////////////////////////
6100  // Generation of Card Interface Container
6101  /////////////////////////////////////////////////////////////
6102  Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6103                                                   - fgkEndCapCardJMDConnectorLength[0]
6104                                                   - fgkEndCapInterfaceCardBThickness
6105                                                   - 9.*fgkEndCapStripConnectionThickness
6106                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6107  const Int_t kcardinterfacecontainervertexnumber = 14;
6108  Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6109  Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6110  xcardinterfacecontainervertex[0]  =-6.5*fgkEndCapCardElectBoardBackThickness
6111                                                                    - 7.0*fgkEndCapStripConnectionThickness;
6112  xcardinterfacecontainervertex[1]  = xcardinterfacecontainervertex[0];
6113  xcardinterfacecontainervertex[2]  = xcardinterfacecontainervertex[1]
6114                                                                    + fgkEndCapStripConnectionThickness
6115                                                                    - fgkEndCapCardElectBoardLayerThickness
6116                                                                    - fgkEndCapCardCableConnectorWidth[0];
6117  xcardinterfacecontainervertex[3]  = xcardinterfacecontainervertex[2];
6118  xcardinterfacecontainervertex[4]  = xcardinterfacecontainervertex[1];
6119  xcardinterfacecontainervertex[5]  = xcardinterfacecontainervertex[4];
6120  xcardinterfacecontainervertex[6]  = 1.5*fgkEndCapCardElectBoardBackThickness
6121                                                                    + 2.0*fgkEndCapStripConnectionThickness;
6122  xcardinterfacecontainervertex[7]  = xcardinterfacecontainervertex[6];
6123  xcardinterfacecontainervertex[8]  = xcardinterfacecontainervertex[7]
6124                                                                    + fgkEndCapInterfaceCardBThickness;
6125  xcardinterfacecontainervertex[9]  = xcardinterfacecontainervertex[8];
6126  xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6127                                                                    + fgkEndCapInterfaceElectBoardCardBThickness;
6128  xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6129  xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6130                                    - fgkEndCapInterfaceElectBoardCardBThickness
6131                                                                    + fgkEndCapCardJMDConnectorLength[0]
6132                                                                    + stiffenertransx+fgkEndCapStiffenerWidth;
6133  xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6134
6135  ycardinterfacecontainervertex[0]  = 0.;
6136  ycardinterfacecontainervertex[1]  = fgkEndCapCardElectBoardLayerWidth[1]
6137                                                                    + fgkEndCapCardJMDConnectorWidth[0]
6138                                                                    + fgkEndCapCardJMDConnectorWidth[1];
6139  ycardinterfacecontainervertex[2]  = ycardinterfacecontainervertex[1];
6140  ycardinterfacecontainervertex[3]  = fgkEndCapCardElectBoardBackWidth[0]
6141                                                                    - fgkEndCapStripConnectionWidth;
6142  ycardinterfacecontainervertex[4]  = ycardinterfacecontainervertex[3];
6143  ycardinterfacecontainervertex[5]  = fgkEndCapCardElectBoardBackWidth[0];
6144  ycardinterfacecontainervertex[6]  = ycardinterfacecontainervertex[5];
6145  ycardinterfacecontainervertex[7]  = fgkEndCapInterfaceCardBWidth[0]
6146                                                                    + fgkEndCapInterfaceCardBWidth[1]
6147                                                                    + fgkEndCapInterfaceCardBWidth[2];
6148  ycardinterfacecontainervertex[8]  = ycardinterfacecontainervertex[7];
6149  ycardinterfacecontainervertex[9]  = yelectboardcardBvertex[3];
6150  ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6151  ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6152  ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6153  ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6154
6155  TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6156  interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6157                                                                                   xcardinterfacecontainervertex,
6158                                                                                   ycardinterfacecontainervertex);
6159  interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6160                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6161  interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6162                                                                            +    fgkEndCapCardElectBoardBackLength[0]));
6163  TGeoVolume** cardinterfacecontainer;
6164  cardinterfacecontainer = new TGeoVolume*[4];
6165  cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6166                                                                                         interfacecardmothershape,fSSDAir);
6167  cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6168                                                                                         interfacecardmothershape,fSSDAir);
6169  cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6170                                                                                         interfacecardmothershape,fSSDAir);
6171  cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6172                                                                                         interfacecardmothershape,fSSDAir);
6173  /////////////////////////////////
6174  // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6175  // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6176  // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6177  // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6178  /////////////////////////////////
6179  TGeoRotation* endcapstripconnectionrot[2];
6180  for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6181  endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6182  endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6183  TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6184                                                                         *                                 (*endcapstripconnectionrot[0]));
6185  TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6186  endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6187                                                                                         -0.5*fgkEndCapCardElectBoardBackThickness,
6188                                                                                          fgkEndCapCardElectBoardBackWidth[0]
6189                                                                                         -endcapstripconnectionshape->GetDZ(),
6190                                                                                          0.5*fgkEndCapCardElectBoardBackLength[0]);
6191  endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6192  TGeoTranslation* cardinterfacetrans[9];
6193  TGeoHMatrix* cardinterfacematrix[9];
6194  for(Int_t i=0; i<7; i++){
6195         cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6196                                                   +                                                     fgkEndCapCardElectBoardBackThickness),
6197                                                                                                 0.0,0.0);
6198         cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6199                                                    *                             (*endcapstripconnectionmatrix));
6200  }
6201  cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6202                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6203                                                                                                 0.0,0.0);
6204  cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6205                                                 *                                 (*endcapstripconnectionmatrix));
6206  cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6207                                                   +                                             fgkEndCapCardElectBoardBackThickness),
6208                                                                                                 0.0,0.0);
6209  cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6210                                                 *                                 (*endcapstripconnectionmatrix));
6211
6212  for(Int_t i=0; i<4; i++){
6213         cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6214                                                                            cardinterfacematrix[7]);
6215         cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6216                                                                            cardinterfacematrix[8]);
6217  }
6218  TGeoTranslation* mothersupplycardtrans =
6219                                         new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6220                                                                                 + 2.*fgkEndCapCardJMDConnectorLength[0]
6221                                                                                 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6222  TGeoHMatrix* mothersupplycardmatrix[7];
6223  Int_t index[4] = {1,1,1,1};
6224  for(Int_t i=0; i<7; i++){
6225         mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6226                                                         *                                 (*mothersupplycardtrans));
6227         for(Int_t j=0; j<4; j++){
6228                 switch(j){
6229                         case 0: //Layer5 EndCap Left Side
6230                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6231                                                                                                    cardinterfacematrix[i]);
6232                                 if(i!=0){
6233                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6234                                                                                                            mothersupplycardmatrix[i]);
6235                                         index[j]++;
6236
6237                                 }
6238                         break;
6239                         case 1: //Layer5 EndCap Rigth Side
6240                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6241                                                                                                    cardinterfacematrix[i]);
6242                                 if(i>0&&i<6){
6243                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6244                                                                                                            mothersupplycardmatrix[i]);
6245                                         index[j]++;
6246                                 }
6247                         break;
6248                         case 2: //Layer6 EndCap Left Side
6249                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6250                                                                                                    cardinterfacematrix[i]);
6251                                 if(i!=6){
6252                                         cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6253                                                                                                            mothersupplycardmatrix[i]);
6254                                         index[j]++;
6255                                 }
6256                         break;
6257                         case 3: //Layer6 EndCap Right Side
6258                                 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6259                                                                                                    cardinterfacematrix[i]);
6260                                 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6261                                                                                                    mothersupplycardmatrix[i]);
6262                                 index[j]++;
6263                         break;
6264                 }
6265         }
6266  }
6267  // Positioning Interface
6268  TGeoTranslation* motherinterfacecardtrans =
6269                 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6270                                                          +0.5*fgkEndCapCardElectBoardBackThickness
6271                                                          -fgkEndCapCardElectBoardLayerThickness
6272                                                          +fgkEndCapStripConnectionThickness,0.,0.);
6273  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6274                                         motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6275  // Positioning Interface Card B
6276  TGeoTranslation* interfacecardBmothertrans =
6277                                         new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6278                                                                                 + 2.*fgkEndCapStripConnectionThickness
6279                                                                                         + fgkEndCapCardElectBoardBackThickness,0.,
6280                                                                            -0.5 * (fgkEndCapInterfaceCardBLength[1]
6281                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6282  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6283                                                                                                                          interfacecardBmothertrans);
6284  // Positioning Stiffener
6285  TGeoTranslation* endcapstiffenertrans =
6286                                                 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6287                                                                            +    2.0*fgkEndCapStripConnectionThickness
6288                                                                            +    fgkEndCapInterfaceCardBThickness
6289                                                                            +    fgkEndCapCardJMDConnectorLength[0]
6290                                                                            +    stiffenertransx
6291                                                                            +    endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6292                                                                                         endcapstiffenershape->GetDZ()
6293                                                                            -    0.5*(fgkEndCapStiffenerLength
6294                                                                            -    fgkEndCapCardElectBoardBackLength[0]));
6295  for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6296  /////////////////////////////////////////////////////////////
6297  // Deallocating memory
6298  /////////////////////////////////////////////////////////////
6299  delete interfacecardBrot;
6300  delete interfacecardBtrans;
6301  delete electboardcardBtrans;
6302  delete electboardcardBrot;
6303  delete jmdconnectorcardBrot;
6304  for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6305  delete jmdconnectorot;
6306  delete jmdconnectortrans[1];
6307  for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6308  delete cableconnectorcombitrans;
6309  delete electboardbacktrans;
6310  delete electboardbackrot;
6311  delete electlayerrot;
6312  for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6313  for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6314  delete mothersupplycardtrans;
6315  for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6316  /////////////////////////////////////////////////////////////
6317  return cardinterfacecontainer;
6318  }
6319  ////////////////////////////////////////////////////////////////////////////////
6320  TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6321   /////////////////////////////////////////////////////////////
6322   // Method returning EndCap Mother Volume
6323   /////////////////////////////////////////////////////////////
6324   const Int_t kendcapcoverplatesmallholenumber = 9;
6325   Double_t endcapmotherorigin[3];
6326   endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6327                                                 +  0.5 *(fgkEndCapCoverPlateLength[3]
6328                                             +  2.0 * fgkEndCapCoverPlateLength[2]);
6329   endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6330                                           -                      fgkEndCapCoverPlateWidth[2]
6331                                           -       (kendcapcoverplatesmallholenumber-1)
6332                                           *        fgkEndCapCoverPlateSmallHoleSeparation[2])
6333                                           +  0.5*(fgkEndCapSideCoverLength[2]
6334                                           +               fgkEndCapCoverPlateWidth[1]
6335                                           -       fgkEndCapCoverPlateWidth[0])
6336                                           -      (fgkEndCapCoverPlateWidth[1]
6337                                           -       fgkEndCapCoverPlateWidth[0]);
6338   endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6339                                                 + 2.*fgkEndCapCoolingTubeRadiusMax
6340                                                 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6341                                                 +      fgkEndCapSideCoverWidth[1]
6342                                                 +      fgkEndCapSideCoverThickness
6343                                                 +      fgkEndCapKaptonFoilThickness);
6344   TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6345                                                           +                              2.0* fgkEndCapCoverPlateLength[2]
6346                                                           +              2.0* fgkEndCapSideCoverThickness),
6347                                                                          0.5* (fgkEndCapSideCoverLength[2]
6348                                                           +                    fgkEndCapCoverPlateWidth[1]
6349                                                           -                                        fgkEndCapCoverPlateWidth[0]),
6350                                                                                          0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6351                                                       +                                    fgkEndCapSideCoverWidth[1]
6352                                                           +                                       fgkEndCapSideCoverThickness
6353                                                       +                                   fgkEndCapKaptonFoilThickness),
6354                                                                                          endcapmotherorigin);
6355   TGeoVolume** endcapassembly;
6356   endcapassembly = new TGeoVolume*[4];
6357   endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6358                                                                                         endcapmothershape,fSSDAir);
6359   endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6360                                                                                         endcapmothershape,fSSDAir);
6361   endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6362                                                                                         endcapmothershape,fSSDAir);
6363   endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6364                                                                                         endcapmothershape,fSSDAir);
6365  /////////////////////////////////
6366  // endcapassembly[0]:  Container End Cap Layer 5 Bellegarde Side
6367  // endcapassembly[1]:  Container End Cap Layer 5 Gex Side
6368  // endcapassembly[2]:  Container End Cap Layer 6 Bellegarde Side
6369  // endcapassembly[3]:  Container End Cap Layer 6 Gex Side
6370  /////////////////////////////////
6371   /////////////////////////////////////////////////////
6372   // Placing Endcap Cover Plate
6373   /////////////////////////////////////////////////////
6374   TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6375   TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6376   endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6377   TGeoCombiTrans* endcapcoverplatecombitrans =
6378                                                   new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6379                                                                                          endcapcoverplaterot);
6380   TGeoTranslation* endcapcoverplatetrans =
6381                                                   new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6382   TGeoHMatrix* endcapcoverplatematrix =
6383                                                   new TGeoHMatrix((*endcapcoverplatetrans)
6384                                                                           *       (*endcapcoverplatecombitrans));
6385   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6386   /////////////////////////////////////////////////////
6387   // Placing Endcap Side Cover
6388   /////////////////////////////////////////////////////
6389   TGeoVolume* endcapsidecover = GetEndCapSideCover();
6390   TGeoRotation* endcapsidecoverot[2];
6391   TGeoCombiTrans* endcapsidecovercombitrans[3];
6392   for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6393   endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6394   endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6395                                                                                         - 0.5*(fgkEndCapCoverPlateWidth[0]
6396                                                                                         - fgkEndCapCoverPlateWidth[2]
6397                                                                                     - (kendcapcoverplatesmallholenumber-1)
6398                                                                                         * fgkEndCapCoverPlateSmallHoleSeparation[2])
6399                                                                                         + 0.*fgkEndCapCoverPlateWidth[0]
6400                                                                                         + fgkEndCapSideCoverLength[2],
6401                                                                                           0.5*(fgkEndCapSideCoverThickness
6402                                                                                         + fgkEndCapCoverPlateThickness)
6403                                                                                         - 0.5*fgkEndCapCoverPlateThickness,
6404                                                                                           endcapsidecoverot[0]);
6405   endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6406   endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6407                                                                                                         0.5*fgkEndCapCoverPlateThickness
6408                                                                                                         -fgkEndCapSideCoverWidth[1],
6409                                                                                                         endcapsidecoverot[1]);
6410   endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6411                                                                                                         +fgkEndCapCoverPlateLength[3]
6412                                                                                                         +2.*fgkEndCapCoverPlateLength[2]
6413                                                                                                         +fgkEndCapSideCoverThickness,0.0,
6414                                                                                                         0.5*fgkEndCapCoverPlateThickness
6415                                                                                                         -fgkEndCapSideCoverWidth[1],
6416                                                                                                         endcapsidecoverot[1]);
6417   TGeoHMatrix* endcapsidecovermatrix[2];
6418   for(Int_t i=0; i<2; i++){
6419    endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6420                                                         *                                 (*endcapsidecovercombitrans[0]));
6421         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6422                                                                                                                 endcapsidecovermatrix[i]);
6423   }
6424   /////////////////////////////////////////////////////
6425   // Placing Endcap Cooling Tube
6426   /////////////////////////////////////////////////////
6427   TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6428   TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6429   endcapcoolingtuberot->SetAngles(0.,180.,0.);
6430   TGeoCombiTrans* endcapccolingtubecombitrans
6431                                                 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6432                                                 + fgkEndCapCoolingTubeAxialRadius[1])
6433                                                 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6434                                                 - fgkEndCapCoolingTubeToCoverSide,
6435                                                   fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6436                                                 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6437   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6438                                                                                                           endcapccolingtubecombitrans);
6439   /////////////////////////////////////////////////////
6440   // Placing Screws
6441   /////////////////////////////////////////////////////
6442   Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6443                                                                            fgkEndCapCoverPlateScrewRadiusMin};
6444   Int_t screwcoverplatedgesnumber[2] = {20,20};
6445   Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6446                                                                                 fgkEndCapCoverPlateThickness
6447                                                                          +  fgkEndCapCoolingTubeRadiusMax};
6448   TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6449                                                                                                  screwcoverplatedgesnumber,
6450                                                                                                  screwcoverplatesection);
6451   TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6452                                                                                            screwcoverplateshape,
6453                                                                                            fSSDCoolingTubePhynox);
6454   screwcoverplate->SetLineColor(12);
6455   Double_t transx[4] = {0,
6456                                                 fgkEndCapCoverPlateSmallHoleSeparation[0],
6457                                                 fgkEndCapCoverPlateSmallHoleSeparation[0]
6458                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1],
6459                                          2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6460                                          +  fgkEndCapCoverPlateSmallHoleSeparation[1]};
6461   const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6462 //  TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6463   TGeoTranslation*** endcapcoverplatescrewtrans;
6464   endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6465   Int_t index = 0;
6466   for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6467         endcapcoverplatescrewtrans[i] =
6468                                         new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6469     for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6470                 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6471         if(index==1||index==9||index==28||index==36){
6472                         endcapcoverplatescrewtrans[i][j] =
6473                                 new TGeoTranslation(transx[i],
6474                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6475                                                                         fgkEndCapSideCoverThickness);
6476                 }
6477                 else{
6478                         endcapcoverplatescrewtrans[i][j] =
6479                                 new TGeoTranslation(transx[i],
6480                                                                         j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6481                                                                         0.);
6482                 }
6483             if(index!=19)
6484                 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6485                                                                                           endcapcoverplatescrewtrans[i][j]);
6486         }
6487   }
6488   /////////////////////////////////////////////////////
6489   // Placing Cover Plate Clips
6490   /////////////////////////////////////////////////////
6491   TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6492                                                                                                          0.5*fgkEndCapCoverPlateClipWidth,
6493                                                                                                          0.5*fgkEndCapSideCoverThickness);
6494   TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6495                                                                                                         endcapcoverplateclipshape,
6496                                                                                                         fSSDCoolingTubePhynox);
6497   TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6498                                                                                                          0.5*fgkEndCapCoverPlateDownClipWidth,
6499                                                                                                          0.5*fgkEndCapSideCoverThickness);
6500   TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6501                                                                                                         endcapcoverplatedownclipshape,
6502                                                                                                         fSSDCoolingTubePhynox);
6503   TGeoTranslation* endcapcoverplatecliptrans[4];
6504   endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6505                                                            -                     fgkEndCapCoverPlateLength[0]
6506                                                            -                     fgkEndCapSideCoverThickness,
6507                                                                                                          0.0,
6508                                                                                                  0.5*(fgkEndCapSideCoverThickness
6509                                                            +                                              fgkEndCapCoverPlateThickness));
6510   endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6511                                                            -                     fgkEndCapCoverPlateLength[0]
6512                                                            -                     fgkEndCapSideCoverThickness,
6513                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6514                                                            *                                     fgkEndCapSideCoverWidth[5],
6515                                                                                                  0.5*(fgkEndCapSideCoverThickness
6516                                                            +                                              fgkEndCapCoverPlateThickness));
6517   endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6518                                                            -                     fgkEndCapCoverPlateLength[0]
6519                                                            +                                     fgkEndCapCoverPlateLength[1]
6520                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6521                                                            -                                     fgkEndCapCoverPlateClipLength
6522                                                            +                                 fgkEndCapSideCoverThickness,
6523                                                                                                          0.0,
6524                                                                                                  0.5*(fgkEndCapSideCoverThickness
6525                                                            +                                              fgkEndCapCoverPlateThickness));
6526   endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6527                                                            -                     fgkEndCapCoverPlateLength[0]
6528                                                            +                                     fgkEndCapCoverPlateLength[1]
6529                                                            +                              2.*fgkEndCapCoverPlateLength[0]
6530                                                            -                                     fgkEndCapCoverPlateClipLength
6531                                                            +                                 fgkEndCapSideCoverThickness,
6532                                                                                                          (kendcapcoverplatescrewnumber[1]-1)
6533                                                            *                                     fgkEndCapSideCoverWidth[5],
6534                                                                                                  0.5*(fgkEndCapSideCoverThickness
6535                                                            +                                              fgkEndCapCoverPlateThickness));
6536   endcapcoverplateclip->SetLineColor(fColorPhynox);
6537   endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6538   for(Int_t i=0; i<4; i++)
6539         for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6540                                                                                                    endcapcoverplatecliptrans[i]);
6541   TGeoTranslation* endcapcoverplatedowncliptrans[4];
6542   endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6543                                                                    -                     fgkEndCapCoverPlateLength[0]
6544                                                                    -                     fgkEndCapSideCoverThickness,
6545                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6546                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6547                                                                                                         0.5*(fgkEndCapSideCoverThickness
6548                                                                +                                         fgkEndCapCoverPlateThickness)
6549                                                                    -                     fgkEndCapSideCoverWidth[1]
6550                                                                    -                                     fgkEndCapSideCoverThickness);
6551   endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6552                                                                    -                     fgkEndCapCoverPlateLength[0]
6553                                                                    -                     fgkEndCapSideCoverThickness,
6554                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6555                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6556                                                                    +                            fgkEndCapSideCoverLength[2]
6557                                                                    -                            fgkEndCapCoverPlateDownClipWidth,
6558                                                                                                         0.5*(fgkEndCapSideCoverThickness
6559                                                                +                                         fgkEndCapCoverPlateThickness)
6560                                                                    -                     fgkEndCapSideCoverWidth[1]
6561                                                                    -                                     fgkEndCapSideCoverThickness);
6562   endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6563                                                                    -                     fgkEndCapCoverPlateLength[0]
6564                                                                    +                     fgkEndCapSideCoverThickness
6565                                                                    +                     fgkEndCapCoverPlateLength[1]
6566                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6567                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6568                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6569                                                                    -                                 fgkEndCapCoverPlateClipWidth),
6570                                                                                                         0.5*(fgkEndCapSideCoverThickness
6571                                                                +                                         fgkEndCapCoverPlateThickness)
6572                                                                    -                     fgkEndCapSideCoverWidth[1]
6573                                                                    -                                     fgkEndCapSideCoverThickness);
6574   endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6575                                                                    -                     fgkEndCapCoverPlateLength[0]
6576                                                                    +                     fgkEndCapSideCoverThickness
6577                                                                    +                     fgkEndCapCoverPlateLength[1]
6578                                                                    +                 2.0*fgkEndCapCoverPlateLength[0]
6579                                                                    -                     fgkEndCapCoverPlateDownClipLength,
6580                                                                                     0.5*(fgkEndCapCoverPlateDownClipWidth
6581                                                                    -                                 fgkEndCapCoverPlateClipWidth)
6582                                                                    +                                 fgkEndCapSideCoverLength[2]
6583                                                                    -                                 fgkEndCapCoverPlateDownClipWidth,
6584                                                                                                         0.5*(fgkEndCapSideCoverThickness
6585                                                                +                                         fgkEndCapCoverPlateThickness)
6586                                                                    -                     fgkEndCapSideCoverWidth[1]
6587                                                                    -                                     fgkEndCapSideCoverThickness);
6588   for(Int_t i=0; i<4; i++)
6589         for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6590                                                                                                    endcapcoverplatedowncliptrans[i]);
6591   /////////////////////////////////////////////////////
6592   // Placing Kapton Foil
6593   /////////////////////////////////////////////////////
6594   TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6595                                                                                                  0.5*fgkEndCapKaptonFoilWidth,
6596                                                                                                  0.5*fgkEndCapKaptonFoilThickness);
6597   TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6598                                                                                                 endcapkaptonfoilshape,
6599                                                                                                 fSSDKaptonFlexMedium);
6600   endcapkaptonfoil->SetLineColor(8);
6601   TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6602                                                                                                                            0.5*fgkEndCapKaptonFoilWidth
6603                                                                                  -                     0.5*fgkEndCapCoverPlateClipWidth,
6604                                                                                                                            0.5*fgkEndCapCoverPlateThickness
6605                                                                                  -                     0.5*fgkEndCapKaptonFoilThickness
6606                                                                              -                     fgkEndCapSideCoverWidth[1]
6607                                                                                  -                     fgkEndCapSideCoverThickness);
6608   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6609   /////////////////////////////////////////////////////////////
6610   // Placing Electronic Tubes
6611   /////////////////////////////////////////////////////////////
6612   Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6613                                                                              - fgkEndCapInterfaceCardBThickness
6614                                                                              - 9.*fgkEndCapStripConnectionThickness
6615                                                                              - 8.*fgkEndCapCardElectBoardBackThickness,
6616                                                                                fgkEndCapKaptonFoilWidth
6617                                                                              - fgkEndCapInterfaceCardBThickness
6618                                                                              - 9.*fgkEndCapStripConnectionThickness
6619                                                                              - 8.*fgkEndCapCardElectBoardBackThickness
6620                                                                                  - fgkEndCapInterfaceElectBoardCardBThickness};
6621   TGeoVolume* endcapeffectivecables[2];
6622   endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6623                                                                                          fgkEndCapEffectiveCableRadiusMax,
6624                                                                                          endcapeffectivecableswidth[0],
6625                                                                                          10,"EndCapEffectiveCables1");
6626   endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6627                                                                                          fgkEndCapEffectiveCableRadiusMax,
6628                                                                                          endcapeffectivecableswidth[1],
6629                                                                                          25,"EndCapEffectiveCables2");
6630   TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6631   TGeoTranslation* endcapeffectivecablestrans[2];
6632   endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6633                                           -                                                        0.5*endcapeffectivecableswidth[0]
6634                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6635                                           -                                                               fgkEndCapCoverPlateWidth[2]
6636                                           -                                             (kendcapcoverplatesmallholenumber-1)
6637                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6638                                           +                                             fgkEndCapSideCoverLength[2],
6639                                           -                     0.5*fgkEndCapCoverPlateThickness
6640                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6641                                           -                                              fgkEndCapInterfaceCardBWidth[0]
6642                                           -                                              fgkEndCapInterfaceCardBWidth[1]));
6643   endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6644                                           -                                                        0.5*endcapeffectivecableswidth[1]
6645                                           -                            0.5*(fgkEndCapCoverPlateWidth[0]
6646                                           -                                                               fgkEndCapCoverPlateWidth[2]
6647                                           -                                             (kendcapcoverplatesmallholenumber-1)
6648                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6649                                           +                                         fgkEndCapSideCoverLength[2],
6650                                           -                     0.5*fgkEndCapCoverPlateThickness
6651                                           -                                             (fgkEndCapCardElectBoardBackWidth[0]
6652                                           -                                              fgkEndCapInterfaceCardBWidth[0])
6653                                           -                     0.5*fgkEndCapInterfaceCardBWidth[2]);
6654   endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6655   TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6656   endcapeffectivecablescombitrans[0]  = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6657                                                                                                                    *endcapeffectivecablesrot);
6658   endcapeffectivecablescombitrans[1]  = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6659                                                                                                                    *endcapeffectivecablesrot);
6660 //  for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6661 //                                                                                                        endcapeffectivecablescombitrans[0]);
6662   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6663                                                                                                           endcapeffectivecablescombitrans[1]);
6664   /////////////////////////////////////////////////////////////
6665   // Placing End Cap Cards
6666   /////////////////////////////////////////////////////////////
6667   TGeoVolume** endcapcards = GetEndCapCards();
6668   TGeoRotation* endcapcardsrot[2];
6669   for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6670   endcapcardsrot[0]->SetAngles(90.,0.,0.);
6671   TGeoTranslation* endcapcardstrans[2];
6672   endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6673                                                                                         -  fgkEndCapCardElectBoardBackLength[0]));
6674   TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6675   endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6676   TGeoHMatrix* endcapcardsmatrix[2];
6677   endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6678   Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6679                                                   - fgkEndCapCardJMDConnectorLength[0]
6680                                                   - fgkEndCapInterfaceCardBThickness
6681                                                   - 9.*fgkEndCapStripConnectionThickness
6682                                                   - 8.*fgkEndCapCardElectBoardBackThickness;
6683   endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6684                                           -                                             fgkEndCapCoverPlateLength[0]
6685                                           + 0.5 *              (fgkEndCapCoverPlateLength[3]
6686                                           + 2.0 *                               fgkEndCapCoverPlateLength[2]),
6687                                           -                                                     stiffenertransx-fgkEndCapStiffenerWidth
6688                                           -                                                               fgkEndCapCardJMDConnectorLength[0]
6689                                           -                                                               fgkEndCapInterfaceCardBThickness
6690                                           -     2.0 *                                             fgkEndCapStripConnectionThickness
6691                                           - 1.5 *                                             fgkEndCapInterfaceCardBThickness
6692                                           - 0.5 *                                                (fgkEndCapCoverPlateWidth[0]
6693                                           -                                                               fgkEndCapCoverPlateWidth[2]
6694                                           -                                             (kendcapcoverplatesmallholenumber-1)
6695                                           *                                             fgkEndCapCoverPlateSmallHoleSeparation[2])
6696                                           +                     fgkEndCapKaptonFoilWidth,
6697                                                                                           0.5*fgkEndCapCoverPlateThickness
6698                                           -                                                     fgkEndCapSideCoverWidth[1]);
6699   endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6700   for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6701    /////////////////////////////////////////////////////////////
6702   // Deallocating memory
6703   /////////////////////////////////////////////////////////////
6704   delete endcapcoverplaterot;
6705   delete endcapcoverplatecombitrans;
6706   delete endcapcoverplatetrans;
6707   for(Int_t i=0; i<3; i++){
6708    delete endcapsidecovercombitrans[i];
6709    if(i<2) delete endcapsidecoverot[i];
6710   }
6711   for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6712   for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6713   delete endcapcardsmatrix[0];
6714   return endcapassembly;
6715  }
6716  ////////////////////////////////////////////////////////////////////////////////
6717  TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6718                                                                                                                         Double_t radiusmax,
6719                                                                                                                         Double_t width,
6720                                                                                                                         Int_t ncables,
6721                                                                                                                         const char* volname){
6722   /////////////////////////////////////////////////////////////
6723   // Generating EndCap High Voltage Tubes
6724   /////////////////////////////////////////////////////////////
6725   Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6726   Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6727
6728   TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6729   TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6730                                                                                                    effectiveouteradius,0.5*width);
6731   TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6732                                                                                                 effectiveinnertubeshape,
6733                                                                                                 fSSDStiffenerConnectorMedium);
6734   effectiveinnertube->SetLineColor(41);
6735   TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6736                                                                                                 effectiveoutertubeshape,
6737                                                                                                 fSSDKaptonChipCableMedium);
6738   effectiveoutertube->SetLineColor(39);
6739   TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6740   TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6741   effectivemothertube->AddNode(effectiveinnertube,1);
6742   effectivemothertube->AddNode(effectiveoutertube,1);
6743   return effectivemothertube;
6744  }
6745  ////////////////////////////////////////////////////////////////////////////////
6746  TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6747   /////////////////////////////////////////////////////////////
6748   // Generating EndCap Support Layer 5 and Layer 6
6749   /////////////////////////////////////////////////////////////
6750   const Int_t knedges = 5;
6751   ///////////////////////////////////////////////
6752   // Setting the vertices for TGeoXtru Up Volume
6753   ///////////////////////////////////////////////
6754   const Int_t klayernumber = 2;
6755   Double_t xupvertex[klayernumber][knedges+3];
6756   Double_t yupvertex[klayernumber][knedges+3];
6757   Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6758   Double_t middledgeangle[klayernumber] = {0.0,0.0};
6759   Double_t middlepsi[klayernumber] = {0.0,0.0};
6760   for(Int_t i=0; i<klayernumber; i++){
6761         xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6762         xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6763         xupvertex[i][2] = -xupvertex[i][1];
6764         xupvertex[i][3] = -xupvertex[i][0];
6765
6766         yupvertex[i][0] =  fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6767         yupvertex[i][1] =  0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6768         yupvertex[i][2] =  yupvertex[i][1];
6769         yupvertex[i][3] =  yupvertex[i][0];
6770
6771     middledgeangle[i] = upedgeangle[i]/knedges;
6772     middlepsi[i] = 90.0-0.5*upedgeangle[i];
6773     for(Int_t j=1; j<knedges; j++){
6774                 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6775                 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6776         }
6777   }
6778   ////////////////////////////////////
6779   // Generating Up TGeoXtru
6780   ////////////////////////////////////
6781   TGeoXtru* upendcapsupportshape[klayernumber];
6782   TGeoVolume* upendcapsupport[klayernumber];
6783   char upendcapsupportname[100];
6784   for(Int_t i=0; i<klayernumber; i++){
6785    upendcapsupportshape[i] = new TGeoXtru(2);
6786    snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
6787    upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6788    upendcapsupportshape[i]->DefineSection(0,0.);
6789    upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6790    upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6791                                                                         fSSDSupportRingAl);
6792    upendcapsupport[i]->SetLineColor(5);
6793   }
6794   ///////////////////////////////////////////////
6795   // Setting the vertices for TGeoXtru Down Volume
6796   ///////////////////////////////////////////////
6797   Double_t xdownvertex[klayernumber][2*(knedges+1)];
6798   Double_t ydownvertex[klayernumber][2*(knedges+1)];
6799   for(Int_t i=0; i<klayernumber; i++){
6800         xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6801         xdownvertex[i][1] =  xupvertex[i][0];
6802         ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6803         ydownvertex[i][1] =  yupvertex[i][0];
6804         for(Int_t j=0; j<knedges; j++){
6805                 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6806                 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6807         }
6808         for(Int_t j=0; j<knedges; j++){
6809                 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6810                                                                         * CosD(middlepsi[i]+j*middledgeangle[i]);
6811                 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6812                                                                         * SinD(middlepsi[i]+j*middledgeangle[i]);
6813         }
6814   }
6815   ////////////////////////////////////
6816   // Generating Down TGeoXtru
6817   ////////////////////////////////////
6818   TGeoXtru* downendcapsupportshape[klayernumber];
6819   TGeoVolume* downendcapsupport[klayernumber];
6820   char downendcapsupportname[100];
6821   for(Int_t i=0; i<klayernumber; i++){
6822         downendcapsupportshape[i] = new TGeoXtru(2);
6823         snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
6824         downendcapsupportshape[i] = new TGeoXtru(2);
6825         downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6826     if(i==0){
6827                 downendcapsupportshape[i]->DefineSection(0,0.);
6828                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6829     }
6830         else{
6831                 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6832                                                                  -                 fgkEndCapSupportLowWidth[i]);
6833                 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6834         }
6835     downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6836                                                                 downendcapsupportshape[i],fSSDSupportRingAl);
6837         downendcapsupport[i]->SetLineColor(5);
6838   }
6839   ///////////////////////////////////////////////
6840   // Setting TGeoPgon Volume
6841   ///////////////////////////////////////////////
6842   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6843                                                                                                    fgkSSDLay6LadderNumber};
6844   TGeoPgon* endcapsupportmothershape[klayernumber];
6845   TGeoVolume** endcapsupportmother;
6846   endcapsupportmother = new TGeoVolume*[klayernumber];
6847   char endcapsupportmothername[100];
6848   for(Int_t i=0; i<klayernumber; i++){
6849         endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6850         snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
6851         endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6852     endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6853                                                                                           ydownvertex[i][0],yupvertex[i][1]);
6854     endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6855                                                                                         fSSDAir);
6856   }
6857   ////////////////////////////////////
6858   TGeoRotation** endcapsupportrot[klayernumber];
6859   for(Int_t i=0; i<2; i++){
6860         endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6861         for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6862            endcapsupportrot[i][j] = new TGeoRotation();
6863            endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6864        endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6865        endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6866         }
6867   }
6868   return endcapsupportmother;
6869  }
6870  ////////////////////////////////////////////////////////////////////////////////
6871  void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6872   /////////////////////////////////////////////////////////////
6873   // Setting End Cap Support Layer 5 and 6.
6874   /////////////////////////////////////////////////////////////
6875   const Int_t kendcapcoverplatesmallholenumber = 9;
6876   const Int_t klayernumber = 2;
6877   const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6878                                                                                                    fgkSSDLay6LadderNumber};
6879   Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6880                                                                                 360.0/kssdlayladdernumber[1]};
6881   TGeoVolume** endcapsupport = EndCapSupport();
6882   TGeoVolume** endcapassembly = GetEndCapAssembly();
6883   TGeoPgon* endcapsupportshape[klayernumber];
6884   Double_t* radiusmin[klayernumber];
6885   Double_t* radiusmax[klayernumber];
6886   for(Int_t i=0; i<klayernumber; i++){
6887     endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6888         radiusmin[i] = endcapsupportshape[i]->GetRmin();
6889         radiusmax[i] = endcapsupportshape[i]->GetRmax();
6890   }
6891   TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6892   Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6893                                                                           endcapassemblyshape->GetDY(),
6894                                                                           endcapassemblyshape->GetDZ()};
6895   ///////////////////////////////////////////////
6896   // Setting TGeoPgon Volume for Mother Container
6897   ///////////////////////////////////////////////
6898   TGeoPgon* endcapsupportsystemshape[klayernumber];
6899   char endcapsupportsystemothername[100];
6900   for(Int_t i=0; i<klayernumber; i++){
6901         endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6902         snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
6903         endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6904                                                                                              - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6905                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6906                                                                                            +2.*endcapassemblycenter[2])
6907                                                                                            /CosD(0.5*upedgeangle[i]));
6908     endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6909                                                                                                  -(fgkEndCapCoverPlateWidth[1]
6910                                                                                              - fgkEndCapCoverPlateWidth[0]),
6911                                                                                            *radiusmin[i],
6912                                                                                           (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6913                                                                                            +2.*endcapassemblycenter[2])
6914                                                                                            /CosD(0.5*upedgeangle[i]));
6915   }
6916   fgkEndCapSupportSystem = new TGeoVolume*[4];
6917   fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6918                                                                           endcapsupportsystemshape[0],fSSDAir);
6919   fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6920                                                                           endcapsupportsystemshape[0],fSSDAir);
6921   fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6922                                                                           endcapsupportsystemshape[1],fSSDAir);
6923   fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6924                                                                           endcapsupportsystemshape[1],fSSDAir);
6925   ///////////////////////////////////////////////
6926   TGeoTranslation* endcapassemblytrans[klayernumber];
6927   for(Int_t i=0; i<klayernumber; i++)
6928         endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6929                                                                            -  fgkEndCapSideCoverThickness
6930                                                                            +  endcapassemblycenter[0],
6931                                                                            -  0.5*fgkEndCapCoverPlateThickness
6932                                                                            -  2.0*fgkEndCapCoolingTubeRadiusMax
6933                                                                            +  2.0*endcapassemblycenter[2]
6934                                                                            +  0.5*fgkEndCapSupportLength[i]
6935                                                                            /  TanD(0.5*upedgeangle[i]),
6936                                                                                   0.5*(fgkEndCapCoverPlateWidth[0]
6937                                                                            -  fgkEndCapCoverPlateWidth[2]
6938                                                                            - (kendcapcoverplatesmallholenumber-1)
6939                                                                            *  fgkEndCapCoverPlateSmallHoleSeparation[2]));
6940   TGeoRotation** endcapassemblyrot[klayernumber];
6941   TGeoHMatrix** endcapassemblymatrix[klayernumber];
6942   for(Int_t i=0; i<klayernumber; i++){
6943    endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6944    endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6945    for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6946    endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6947    endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6948    endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6949    endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6950    for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6951         endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6952         endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6953    }
6954   }
6955   TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6956                                                         fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6957   for(Int_t i=0; i<2*klayernumber; i++){
6958         for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6959                 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6960                                                                                                                                            endcapassemblymatrix[1][j+2]);
6961         }
6962         fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6963   }
6964    /////////////////////////////////////////////////////////////
6965   // Deallocating memory
6966   /////////////////////////////////////////////////////////////
6967   for(Int_t i=0; i<klayernumber; i++){
6968         for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6969                 delete endcapassemblyrot[i][j];
6970         }
6971         delete [] endcapassemblyrot[i];
6972         delete endcapassemblymatrix[i][0];
6973         delete endcapassemblymatrix[i][1];
6974   }
6975   /////////////////////////////////////////////////////////////
6976   }
6977   void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6978   /////////////////////////////////////////////////////////////
6979   // Setting End Cap Support + End Cap Assembly of Layer 5.
6980   /////////////////////////////////////////////////////////////
6981   if (! moth) {
6982     AliError("Can't insert end cap support of layer5, mother is null!\n");
6983     return;
6984   };
6985   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
6986   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6987   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6988                                                                                                 fgkEndCapSupportCenterLay5ITSPosition
6989                                                                            +            fgkEndCapSupportCenterLay5Position
6990                                                                            -            fgkEndCapSideCoverLength[2]);
6991   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6992                                                                                                 fgkEndCapSideCoverLength[2]
6993                                                                            -        fgkEndCapSupportCenterLay5Position
6994                                                                            -        fgkEndCapSupportCenterLay5ITSPosition);
6995   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6996   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6997   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6998         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6999   moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7000   moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7001    /////////////////////////////////////////////////////////////
7002   // Deallocating memory
7003   /////////////////////////////////////////////////////////////
7004   delete endcapsupportsystemrot;
7005   delete endcapsupportsystemITSCentertrans[1];
7006  }
7007   /////////////////////////////////////////////////////////////
7008   void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7009   /////////////////////////////////////////////////////////////
7010   // Setting End Cap Support + End Cap Assembly of Layer 6.
7011   /////////////////////////////////////////////////////////////
7012   if (! moth) {
7013     AliError("Can't insert end cap support of layer6, mother is null!\n");
7014     return;
7015   };
7016   if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7017   TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7018   endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7019                                                                                                 fgkEndCapSupportCenterLay6ITSPosition
7020                                                                            +            fgkEndCapSupportCenterLay6Position
7021                                                                            -            fgkEndCapSideCoverLength[2]);
7022   endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7023                                                                                                 fgkEndCapSideCoverLength[2]
7024                                                                            -        fgkEndCapSupportCenterLay6Position
7025                                                                            -        fgkEndCapSupportCenterLay6ITSPosition);
7026   TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7027   endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7028   TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7029         new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7030   moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7031   moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7032    /////////////////////////////////////////////////////////////
7033   // Deallocating memory
7034   /////////////////////////////////////////////////////////////
7035   delete endcapsupportsystemrot;
7036   delete endcapsupportsystemITSCentertrans[1];
7037  }
7038  ////////////////////////////////////////////////////////////////////////////////
7039  void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7040   /////////////////////////////////////////////////////////////
7041   // Setting Ladder Support of Layer 5.
7042   /////////////////////////////////////////////////////////////
7043   if (! moth) {
7044     AliError("Can't insert ladder lupport of layer5, mother is null!\n");
7045     return;
7046   };
7047   if(!fLay5LadderSupportRing) SetLadderSupport(100);
7048   fMotherVol = moth;
7049   TGeoTranslation* centerITSRingSupportLay5trans[2];
7050   for(Int_t i=0; i<2; i++){
7051         centerITSRingSupportLay5trans[i] =
7052                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7053     moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7054   }
7055  }
7056  ////////////////////////////////////////////////////////////////////////////////
7057  void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7058   /////////////////////////////////////////////////////////////
7059   // Setting Ladder Support of Layer 6.
7060   /////////////////////////////////////////////////////////////
7061   if (! moth) {
7062     AliError("Can't insert ladder lupport of layer6, mother is null!\n");
7063     return;
7064   };
7065   if(!fLay6LadderSupportRing) SetLadderSupport(100);
7066   fMotherVol = moth;
7067   TGeoTranslation* centerITSRingSupportLay6trans[2];
7068   for(Int_t i=0; i<2; i++){
7069         centerITSRingSupportLay6trans[i] =
7070                 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7071     moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7072   }
7073  }
7074  ////////////////////////////////////////////////////////////////////////////////
7075  void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7076   /////////////////////////////////////////////////////////////
7077   // Setting Ladder Support of Layer 6.
7078   /////////////////////////////////////////////////////////////
7079   if (! moth) {
7080     AliError("Can't insert SSD Cone, mother is null!\n");
7081     return;
7082   };
7083   if(!fSSDCone) SetSSDCone();
7084   TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7085                                                                 +                                         fgkSSDCentralAL3SupportLength);
7086     moth->AddNode(fSSDCone,1,ssdconetrans);
7087 }
7088  ////////////////////////////////////////////////////////////////////////////////
7089  void AliITSv11GeometrySSD::SetSSDCone(){
7090   /////////////////////////////////////////////////////////////
7091   // Method generating SSDCone
7092   /////////////////////////////////////////////////////////////
7093   if(!fCreateMaterials) CreateMaterials();
7094   fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7095   Double_t ssdpconesectionradiusmax[16];
7096   Double_t ssdpconesectionradiusmin[16];
7097   Double_t ssdpconezsection[16];
7098   TGeoPcon* ssdpconelittleholeshape[8];
7099   TGeoVolume* ssdpconelittlehole[8];
7100   ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7101   ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7102   ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7103                                                       / SinD(fgkSSDPConeAngle)
7104                                                           + ssdpconesectionradiusmin[0];
7105   ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7106                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7107                                                           / SinD(fgkSSDPConeAngle);
7108   ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7109   ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7110                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7111   ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7112   for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7113                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7114   ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7115   ssdpconelittlehole[0]->SetLineColor(4);
7116   /////////////////////////////////////////////////////////////
7117   ssdpconezsection[2] = ssdpconezsection[1];
7118   ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7119   ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7120   ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7121                                                           - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7122                                                           / SinD(fgkSSDPConeAngle);
7123   ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7124                                                           / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7125   ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7126                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7127   Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7128                                                                    * TMath::RadToDeg();
7129   ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7130                                                                                                           60.-ssdpconelittleholeangle,2);
7131   for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7132                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7133   ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7134   ssdpconelittlehole[1]->SetLineColor(4);
7135   TGeoRotation* ssdconelittleholerot[6];
7136   for(Int_t i=0; i<6; i++){
7137         ssdconelittleholerot[i] = new TGeoRotation();
7138     ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7139   }
7140   /////////////////////////////////////////////////////////////
7141   ssdpconezsection[4] = ssdpconezsection[3];
7142   ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7143   ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7144   ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7145                                                           * CosD(fgkSSDPConeAngle)
7146                                                           / SinD(fgkSSDPConeAngle);
7147   ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7148   ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7149                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7150   ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7151   for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7152                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7153   ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7154   ssdpconelittlehole[2]->SetLineColor(4);
7155   ///////////////////////////////////////////////////
7156   ssdpconezsection[6] = ssdpconezsection[5];
7157   ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7158   ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7159   ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7160                                                           -ssdpconezsection[0]
7161                                                           * CosD(fgkSSDPConeAngle)
7162                                                           / SinD(fgkSSDPConeAngle);
7163   ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7164   ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7165                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7166   Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7167                                                                    * TMath::RadToDeg();
7168   ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7169                                                                                                           45.-ssdpconemiddleholeangle,2);
7170   for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7171                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7172   ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7173   ssdpconelittlehole[3]->SetLineColor(4);
7174   TGeoRotation* ssdconemiddleholerot[8];
7175   for(Int_t i=0; i<8; i++){
7176         ssdconemiddleholerot[i] = new TGeoRotation();
7177     ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7178   }
7179   /////////////////////////////////////////////////////////////
7180   ssdpconezsection[8] = ssdpconezsection[7];
7181   ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7182   ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7183   ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7184                                                           * CosD(fgkSSDPConeAngle)
7185                                                           / SinD(fgkSSDPConeAngle);
7186   ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7187   ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7188                                           * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7189   ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7190   for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7191                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7192   ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7193   ssdpconelittlehole[4]->SetLineColor(4);
7194   /////////////////////////////////////////////////////////////
7195   Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7196   Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7197                                                                  * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7198                                                                  -  0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7199                                                                  -  0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7200                                                                  -  0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7201   Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7202   Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7203                                                                                  * TMath::RadToDeg();
7204   ssdpconezsection[10] = ssdpconezsection[9];
7205   ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7206   ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7207   ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7208                                                           * CosD(fgkSSDPConeAngle)
7209                                                           / SinD(fgkSSDPConeAngle);
7210   ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7211   ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7212                                            * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7213   ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7214                                                                                         ssdpconetrapezoidsectionangle,2);
7215   for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7216                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7217   ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7218   ssdpconelittlehole[5]->SetLineColor(4);
7219   TGeoRotation* ssdconeupradiusrot[8];
7220   for(Int_t i=0; i<8; i++){
7221         ssdconeupradiusrot[i] = new TGeoRotation();
7222     ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7223   }
7224   /////////////////////////////////////////////////////////////
7225   ssdpconezsection[12] = ssdpconezsection[11];
7226   ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7227   ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7228   ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7229   ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7230   ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7231   ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7232   for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7233                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7234   ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7235   ssdpconelittlehole[6]->SetLineColor(4);
7236   /////////////////////////////////////////////////////////////
7237   ssdpconezsection[14] = 0.0;
7238   ssdpconezsection[15] = ssdpconezsection[0];
7239   ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7240   ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7241   ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7242   ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7243   ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7244   for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7245                                                   ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7246   ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7247   ssdpconelittlehole[7]->SetLineColor(4);
7248   /////////////////////////////////////////////////////////////
7249   TGeoTube* ssdtubeconeshape[2];
7250   TGeoVolume* ssdtubecone[2];
7251   TGeoTranslation* ssdtubeconetrans[2];
7252   ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7253                                                                            fgkSSDPConeExternalRadius,
7254                                                                            0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7255   ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7256                                                                            0.5*ssdpconezsection[0]);
7257   ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7258   ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7259   ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7260                                                 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7261                                           + ssdpconezsection[13]);
7262   ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7263   ssdtubecone[0]->SetLineColor(4);
7264   ssdtubecone[1]->SetLineColor(4);
7265   /////////////////////////////////////////////////////////////
7266   // Mother Volume Container
7267   /////////////////////////////////////////////////////////////
7268   Double_t ssdconemotherradiusmin[8];
7269   Double_t ssdconemotherradiusmax[8];
7270   Double_t ssdconemothersection[8];
7271   ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7272   ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7273   ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7274   ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7275   ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7276   ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7277   ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7278   ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7279   ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7280   ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7281   ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7282   ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7283   ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7284   ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7285   ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7286   ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7287   ssdconemothersection[0] = 0.0;
7288   ssdconemothersection[1] = ssdpconezsection[0];
7289   ssdconemothersection[2] = ssdpconezsection[0];
7290   ssdconemothersection[3] = ssdpconezsection[11];
7291   ssdconemothersection[4] = ssdpconezsection[11];
7292   ssdconemothersection[5] = ssdpconezsection[13];
7293   ssdconemothersection[6] = ssdpconezsection[13];
7294   ssdconemothersection[7] = fgkSSDPConeLength;
7295   TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7296   for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7297                                                                         ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7298   TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7299   /////////////////////////////////////////////////////////////
7300   //Placing the Volumes into Mother
7301   /////////////////////////////////////////////////////////////
7302   ssdconemother->AddNode(ssdpconelittlehole[0],1);
7303   for(Int_t i=0; i<6; i++){
7304         ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7305   }
7306   ssdconemother->AddNode(ssdpconelittlehole[2],1);
7307   for(Int_t i=0; i<8; i++){
7308     ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7309   }
7310   ssdconemother->AddNode(ssdpconelittlehole[4],1);
7311   for(Int_t i=0; i<8; i++){
7312     ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7313   }
7314   ssdconemother->AddNode(ssdpconelittlehole[6],1);
7315   ssdconemother->AddNode(ssdpconelittlehole[7],1);
7316   ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7317   ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7318   /////////////////////////////////////////////////////////////
7319   // ITS General Support
7320   /////////////////////////////////////////////////////////////
7321   TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7322                                                                 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7323   TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7324   TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7325                                                                              - fgkSSDCentralAL3SupportLength);
7326   ssdcentralsupport->SetLineColor(4);
7327   fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7328   TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7329                                                                 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7330   TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7331   TGeoTranslation* ssdcentralal3supportrans[3];
7332   ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7333   ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7334                                                           - 1.25*fgkSSDCentralAL3SupportLength);
7335   ssdcentralal3support->SetLineColor(4);
7336   fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7337   fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7338   TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7339   Double_t ssdpconcentralradiusmin[2];
7340   Double_t ssdpconcentralradiusmax[2];
7341   Double_t ssdpconcentralsection[2];
7342   ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7343   ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7344   ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7345   ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7346   ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7347   ssdpconcentralsection[1] = 0.;
7348   for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7349                                                   ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7350   TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7351   ssdpconcentralal3->SetLineColor(4);
7352   fSSDCone->AddNode(ssdpconcentralal3,1);
7353   TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7354   ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7355   ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7356                                                                 -2.*fgkSSDCentralAL3SupportLength);
7357   TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7358                                                                                                                      *ssdcentralal3supportrot);
7359   fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7360   TGeoRotation* ssdconemotherot = new TGeoRotation();
7361   ssdconemotherot->SetAngles(90.,180.,-90.);
7362   TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7363                                                                                                                         -2.*fgkSSDCentralAL3SupportLength);
7364   TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7365   fSSDCone->AddNode(ssdconemother,1);
7366   fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7367   /////////////////////////////////////////////////////////////
7368   // Deallocating memory
7369   /////////////////////////////////////////////////////////////
7370   delete ssdcentralal3supportrot;
7371   delete ssdcentralal3supportrans[2];
7372   delete ssdconemotherot;
7373   delete ssdconemothertrans;
7374   /////////////////////////////////////////////////////////////
7375  }
7376  ////////////////////////////////////////////////////////////////////////////////
7377  void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7378   /////////////////////////////////////////////////////////////
7379   // Setting SSD Cables
7380   /////////////////////////////////////////////////////////////
7381   if (! moth) {
7382     AliError("Can't insert SSD Cables, mother is null!\n");
7383     return;
7384   };
7385   TGeoVolume* ssdcables = SetSSDCables();
7386   moth->AddNode(ssdcables,1);
7387 }
7388  ////////////////////////////////////////////////////////////////////////////////
7389  TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7390    /////////////////////////////////////////////////////////////
7391    // Method generating SSDCables
7392    /////////////////////////////////////////////////////////////
7393
7394    /////////////////////////////////////////////////////////////////////////////////
7395    // SSD Cables Parameters (lengths are in mm and angles in degrees)
7396    /////////////////////////////////////////////////////////////////////////////////
7397
7398    const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7399    const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7400
7401    // Cable thickness for rings at outer Z
7402    // Average: 9/2 = 4.5 cables per quadrant
7403    // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
7404
7405    const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
7406    const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
7407
7408
7409    const Double_t kSSDCablesHeight = 3.2*fgkmm;  // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
7410
7411    const Double_t kSSDCableAngle = 22.5;
7412    // MvL: remove water?
7413    const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm;  // to be fixed in order to reproduce material budget
7414    const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7415    const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7416    const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7417    const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7418    const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7419    const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7420    const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7421
7422    // SSD Layer 5 Cables
7423    //////////////////////////////////////////////////////////////////////////////////////////////////
7424    TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7425    Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7426    Double_t ssdcablelaylateral = 0.55;   // Internal variables to control overlapping with SDD cables
7427    //////////////////////////////////////////////////////////////////////////////////////////////////
7428   // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7429
7430
7431
7432   ////////////////////////////////////
7433   //  Double_t cablescapacity[20];
7434   //  cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7435   ////////////////////////////////////
7436   //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7437   ////////////////////////////////////
7438   // TGeoPCone Volumes
7439   ///////////////////////////////////
7440   TGeoPcon* ssdcableslay5pconshape[3];
7441   TGeoVolume* ssdcableslay5pcon[3];
7442   ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7443   Double_t ssdcableslay5pconzsection[6];
7444   Double_t ssdcableslay5pconrmin[6];
7445   Double_t ssdcableslay5pconrmax[6];
7446   ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7447   ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7448
7449   ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7450                                  + fgkEndCapSupportCenterLay5Position;
7451                                 //+ 2.*ssdcablelay5rightsidelength;  // removing this generates overlap with the water ring
7452                                 // Keeping it generates overlap with the cones...
7453   // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
7454   ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7455                                                            + fgkSSDCentralAL3SupportLength
7456                                                            + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7457                                                            * TanD(fgkSSDPConeAngle);
7458   Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7459   Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7460   ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7461   ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7462   //Printf(Form("pcone: r1 %g  r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7463   //          ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7464
7465   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7466                                                   ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7467   ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7468                                                            ssdcableslay5pconshape[0],fSSDCopper);
7469   ssdcableslay5pcon[0]->SetLineColor(9);
7470   ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7471
7472   Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7473   // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
7474 ////////////////////////////////////
7475 //  cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7476 ////////////////////////////////////
7477
7478   //
7479   //   PCon 2 and 3 are cables going through/towards holes in supports
7480   //
7481   ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7482   ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7483                                                            + fgkSSDCentralAL3SupportLength
7484                                                            + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7485                                                            + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7486   Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7487                                              -  fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7488                                                  /  fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7489   ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7490                                                                                    ssdcableangle,2);
7491   // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
7492   ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7493   ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7494   ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7495                                                    - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7496   ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7497   ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
7498   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7499                                                   ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7500   ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7501   ssdcableslay5pcon[1]->SetLineColor(9);
7502   ////////////////////////////////////
7503   ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7504                                                                                    ssdcableangle,2);
7505   ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7506   ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7507   ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7508   ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7509   ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7510   ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7511                                                            * TanD(fgkSSDPConeAngle)
7512                                                            + 0.5*fgkSSDCentralSupportLength
7513                                                            + fgkSSDCentralAL3SupportLength;
7514   ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7515   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7516                                                   ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7517   ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7518   ssdcableslay5pcon[2]->SetLineColor(9);
7519 ////////////////////////////////////
7520   TGeoRotation* ssdcableslay5pconrot[4];
7521   for(Int_t i=0; i<4; i++){
7522    ssdcableslay5pconrot[i] = new TGeoRotation();
7523    ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7524    ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7525    ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7526    // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7527    totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
7528   }
7529   ////////////////////////////////////
7530   //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7531   //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7532   ////////////////////////////////////
7533   // Positioning Left SSD Cables Part
7534   ////////////////////////////////////
7535   TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7536   ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7537   ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7538   TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7539   for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7540         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7541         ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7542     ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7543   }
7544   ////////////////////////////////////
7545   //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7546   //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7547   //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7548   //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7549   /////////////////////////////////////////////////////////////
7550   // Water Tubes Layer 5
7551   /////////////////////////
7552   /*  Remove ring; could be replaced with a PCone next to/on top of the cables
7553
7554    //
7555    // MvL: Remove ring; put everything in PCone
7556    //
7557    // Need to keep dimensions for water ring...
7558
7559    Double_t ssdcablesfactor = 0.5;     // Internal variables to control overlapping with SDD cables
7560
7561   Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7562   Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7563                                                                             -  fgkSSDLowerPConeRadius)
7564                                                                             * TanD(fgkSSDPConeAngle);
7565   Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7566                                                                               + fgkEndCapSupportCenterLay5Position
7567                                                                               - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7568   Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7569                                                                            - ssdcableslay5startconedistance;
7570   ssdcablelay5rightsidelength *= ssdcablesfactor;
7571   Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7572
7573
7574   TGeoTranslation* ssdcablelay5rightrans =
7575                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7576                                                                     + fgkEndCapSupportCenterLay5Position
7577                                                                     + 0.5*ssdcablelay5rightsidelength);
7578
7579   TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7580                                                                                                         - 0.5*ssdcablelay5rightsidelength
7581                                                                                                         - fgkEndCapSupportCenterLay5Position
7582                                                                                                     - fgkEndCapSupportCenterLay5ITSPosition);
7583
7584   TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7585                                                                                      ssdcableslay5rightsideradiusmax
7586                                                                                + kSSDCablesLay5RightSideWaterHeight,
7587                                                                                      0.5*ssdcablelay5rightsidelength);
7588   TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7589                                                                                                          ssdcablelay5rightubewatershape,
7590                                                                                                          fSSDCoolingTubeWater);
7591   ssdcablelay5rightwatertube->SetLineColor(7);
7592   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7593   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7594   */
7595   ////////////////////////////////////
7596   // TGeoPCone Water Volumes Layer
7597   ///////////////////////////////////
7598   TGeoPcon* ssdcableslay5pconwatershape[3];
7599   TGeoVolume* ssdcableslay5pconwater[3];
7600   ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7601   Double_t ssdcableslay5pconwaterzsection[6];
7602   Double_t ssdcableslay5pcwateronrmin[6];
7603   Double_t ssdcableslay5pconwaterrmax[6];
7604   ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7605   ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7606                                                                 + kSSDCablesLay5RightSideWaterHeight;
7607   ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7608   ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7609                                                                 + kSSDCablesLay5RightSideWaterHeight;
7610   ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7611   ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7612   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7613                                                   ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7614   ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7615                                                            ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7616   ssdcableslay5pconwater[0]->SetLineColor(7);
7617   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7618   ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7619 ////////////////////////////////////
7620   ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7621   ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7622   ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7623                                                                                                 ssdcableangle,2);
7624   ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7625   ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7626                                                                 + kSSDCablesLay5RightSideWaterHeight;
7627   ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7628   ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7629                                                                 + kSSDCablesLay5RightSideWaterHeight;
7630   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7631                                                   ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7632   ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7633                                                            ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7634   ssdcableslay5pconwater[1]->SetLineColor(7);
7635 ////////////////////////////////////
7636   ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7637                                                                                                 ssdcableangle,2);
7638   ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7639   ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7640                                                                 + kSSDCablesLay5RightSideWaterHeight;
7641   ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7642   ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7643                                                                 + kSSDCablesLay5RightSideWaterHeight;
7644   ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7645   ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7646   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7647                                                   ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7648   ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7649                                                            ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7650   ssdcableslay5pconwater[2]->SetLineColor(7);
7651 ////////////////////////////////////
7652   TGeoRotation* ssdcableslay5pconwaterot[4];
7653   TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7654   for(Int_t i=0; i<4; i++){
7655    ssdcableslay5pconwaterot[i] = new TGeoRotation();
7656    ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7657    ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7658         new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7659         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7660         ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7661         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7662         ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7663   }
7664   /////////////////////////
7665   // SSD Layer 6 Cables
7666   /////////////////////////
7667   Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7668   Double_t ssdcablelay6rightsidelength = 2.; // cm  was 2.*ssdcablelay5rightsidelength;
7669   Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7670   // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
7671   TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7672                                                                                                 ssdcableslay6rightsideradiusmax,
7673                                                                                                 0.5*ssdcablelay6rightsidelength);
7674   TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7675                                                                                                          ssdcablelay6rightubeshape,
7676                                                                                                          fSSDCopper);
7677   ssdcablelay6righttube->SetLineColor(9);
7678   TGeoTranslation* ssdcablelay6rightrans =
7679                                           new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7680                                                                                  +              fgkEndCapSupportCenterLay6Position
7681                                                                                  +      0.5*ssdcablelay6rightsidelength);
7682   TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7683                                                                                                         - 0.5*ssdcablelay6rightsidelength
7684                                                                                                         - fgkEndCapSupportCenterLay6Position
7685                                                                                                     - fgkEndCapSupportCenterLay6ITSPosition);
7686   ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7687   ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7688   // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7689   totvol += ssdcablelay6rightubeshape->Capacity();
7690   ////////////////////////////////////
7691   //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7692   ////////////////////////////////////
7693   // MvL: PCon is part of connection to patch panels;
7694   // removed since current volume is too thick; now absorbed in rings+connections
7695   /*
7696   TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7697                                                                                    ssdcableangle,2);
7698   TGeoVolume* ssdcableslay6pcon;
7699   Double_t ssdcableslay6pconrmin[2];
7700   Double_t ssdcableslay6pconrmax[2];
7701   Double_t ssdcableslay6pconzsection[2];
7702   ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7703   ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7704   ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7705   ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7706   ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7707                                                            + fgkEndCapSupportCenterLay6Position
7708                                                            + ssdcablelay6rightsidelength;
7709   ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7710   for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7711                                                   ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7712
7713   ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7714                                                            ssdcableslay6pconshape,fSSDCopper);
7715   ssdcableslay6pcon->SetLineColor(9);
7716   for(Int_t i=0; i<4; i++){
7717    ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7718    ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7719   }
7720   */
7721   ////////////////////////////////////
7722   //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7723   /////////////////////////
7724   // Water Tubes Layer 6
7725   /////////////////////////
7726   TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7727                                                                                                                   ssdcableslay6rightsideradiusmax
7728                                                                                    +                      kSSDCablesLay5RightSideWaterHeight,
7729                                                                                                                   0.5*ssdcablelay6rightsidelength);
7730   TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7731                                                                                                          ssdcablelay6righwatertubeshape,
7732                                                                                                          fSSDCoolingTubeWater);
7733   ssdcablelay6rightwatertube->SetLineColor(7);
7734   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7735   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7736   TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7737                                                                                    ssdcableangle,2);
7738   TGeoVolume* ssdcableslay6waterpcon;
7739   Double_t ssdcableslay6waterpconrmin[2];
7740   Double_t ssdcableslay6waterpconrmax[2];
7741   Double_t ssdcableslay6waterpconzsection[2];
7742   ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7743   ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7744                                                             + kSSDCablesLay5RightSideWaterHeight;
7745   ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7746   ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7747   ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7748                                                            + fgkEndCapSupportCenterLay6Position
7749                                                            + ssdcablelay6rightsidelength;
7750   ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7751   for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7752                                                   ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7753   ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7754                                                            ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7755   ssdcableslay6waterpcon->SetLineColor(7);
7756   TGeoRotation* ssdcableslay6pconwaterot[4];
7757   TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7758   ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7759   TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7760   for(Int_t i=0; i<4; i++){
7761    ssdcableslay6pconwaterot[i] = new TGeoRotation();
7762    ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7763    ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7764                                                                                  * (*ssdcableslay6pconwaterot[i]));
7765    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7766    ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7767   }
7768   ////////////////////////////////////////
7769   // From ITS Ring to Patch Panel3-RB26
7770   ////////////////////////////////////////
7771   Double_t ssdcablepatchpanel3BB26radiusmin[2];
7772   Double_t ssdcablepatchpanel3BB26radiusmax[2];
7773   Double_t ssdcablepatchpanel3RB26zsection[2];
7774   ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
7775   ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7776                                         + kSSDCablesHeight;
7777   ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
7778   ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7779                                         + kSSDCablesHeight;
7780   ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7781                                         + fgkSSDCentralAL3SupportLength
7782                                                                                  + fgkSSDPConeZLength[0];
7783   ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7784   // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7785   // Printf(Form("Angular range %g",ssdcableangle));
7786
7787   TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7788                                                                 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
7789                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7790   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7791                                                   ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7792   TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7793                                                                                                 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7794   ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7795   TGeoRotation* ssdcablepatchpanel3B26rot[4];
7796   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7797   ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7798   ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7799                                           + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7800   ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7801   ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7802                                                 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7803   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7804   // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
7805   ////////////////////////////////////
7806   //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7807   ////////////////////////////////////////
7808   //  ITS Ring Cables RB26 Part
7809   ////////////////////////////////////////
7810   Double_t ssdcableitsring3BB26pconzsection[2];
7811   Double_t ssdcableitsring3BB26pconrmin[2];
7812   Double_t ssdcableitsring3BB26pconrmax[2];
7813   ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7814                                                                           + fgkSSDCentralAL3SupportLength
7815                                                                           + (4.0/5.0)*fgkSSDPConeZLength[0];
7816   ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7817   ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7818   ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7819
7820   ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7821   ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7822   TGeoPcon* ssdcableitsring3BB26pconshape[4];
7823   ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
7824                                                                    -              0.5*ssdcableangle,ssdcableangle
7825                                                                    +                            (kSSDCablesPatchPanel2RB26Angle[0]
7826                                                                    -                             kSSDCableAngle),2);
7827   ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
7828                                                                    -              0.5*ssdcableangle,ssdcableangle
7829                                                                    +                      3.0*kSSDCableAngle
7830                                                                    -                      kSSDCablesPatchPanel2RB26Angle[1],2);
7831   ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
7832                                                                    -              0.5*ssdcableangle,ssdcableangle
7833                                                                    -                      kSSDCableAngle
7834                                                                    +                      kSSDCablesPatchPanel2RB26Angle[0],2);
7835   ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
7836                                                                    -              0.5*ssdcableangle,ssdcableangle
7837                                                                    +                      3.0*kSSDCableAngle
7838                                                                    -                      kSSDCablesPatchPanel2RB26Angle[1],2);
7839   for(Int_t i=0;i<4;i++)
7840         for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7841                                                          ssdcableitsring3BB26pconrmin[j],
7842                                                          ssdcableitsring3BB26pconrmax[j]);
7843   TGeoVolume* ssdcableitsring3BB26pcon[4];
7844   ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7845                                                                                                 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7846   ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7847                                                                                                 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7848   ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7849                                                                                                 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7850   ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7851                                                                                                 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7852   for(Int_t i=0;i<4;i++){
7853         ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7854         ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
7855         //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
7856 }
7857
7858   ////////////////////////////////////
7859   //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7860   //                             + ssdcableitsring3BB26pconshape[1]->Capacity()
7861   //                             + ssdcableitsring3BB26pconshape[2]->Capacity()
7862   //                             + ssdcableitsring3BB26pconshape[3]->Capacity();
7863   ////////////////////////////////////////
7864   // From ITS Ring to Patch Panel2-RB24
7865   ////////////////////////////////////////
7866   Double_t ssdcablepatchpanel3BB24radiusmin[2];
7867   Double_t ssdcablepatchpanel3BB24radiusmax[2];
7868   Double_t ssdcablepatchpanel3RB24zsection[2];
7869   ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7870   ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7871   ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
7872   ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7873                                         + kSSDCablesHeight;
7874   ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7875                                                                          -  fgkSSDCentralAL3SupportLength
7876                                                                          -  fgkSSDPConeZLength[0];
7877   ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7878   //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
7879   TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7880                                                                 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
7881                                                                                                 - 0.5*ssdcableangle,ssdcableangle,2);
7882   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7883                                                   ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7884   TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7885                                                                                                 ssdcablepatchpanel3RB24pconshape,
7886                                                                                                 fSSDCopper);
7887   ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7888   TGeoRotation* ssdcablepatchpanel3B24rot[4];
7889   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7890   ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
7891   ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7892                                           + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7893   ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
7894   ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7895                                           + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7896   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7897   //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
7898   ////////////////////////////////////
7899   //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7900   ////////////////////////////////////////
7901   //  ITS Ring Cables RB24 Part
7902   ////////////////////////////////////////
7903   Double_t ssdcableitsring3BB24pconzsection[2];
7904   Double_t ssdcableitsring3BB24pconrmin[2];
7905   Double_t ssdcableitsring3BB24pconrmax[2];
7906   ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7907   ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7908   ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7909   ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight;  // Cable bunch width smaller; make it thicker
7910
7911   ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7912   ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7913   TGeoPcon* ssdcableitsring3BB24pconshape[4];
7914   ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7915                                                                + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7916                                                                    - kSSDCableAngle),2);
7917   ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7918                                                                      ssdcableangle-kSSDCableAngle
7919                                                                    + kSSDCablesPatchPanel2RB24Angle[0],2);
7920   ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7921                                                                    - kSSDCableAngle
7922                                                                    + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7923   ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7924                                                                    ssdcableangle-kSSDCableAngle
7925                                                                    + kSSDCablesPatchPanel2RB24Angle[0],2);
7926   for(Int_t i=0;i<4;i++)
7927         for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7928                                                          ssdcableitsring3BB24pconrmin[j],
7929                                                          ssdcableitsring3BB24pconrmax[j]);
7930   TGeoVolume* ssdcableitsring3BB24pcon[4];
7931   ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7932                                                                                                 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7933   ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7934                                                                                                 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7935   ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7936                                                                                                 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7937   ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7938                                                                                                 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7939   for(Int_t i=0;i<4;i++){
7940         ssdcableitsring3BB24pcon[i]->SetLineColor(9);
7941         ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
7942         // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
7943 }
7944
7945   ////////////////////////////////////
7946   //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7947   //                                     + ssdcableitsring3BB24pconshape[1]->Capacity()
7948   //                                     + ssdcableitsring3BB24pconshape[2]->Capacity()
7949   //                                     + ssdcableitsring3BB24pconshape[3]->Capacity();
7950
7951   // MvL: Pcon are connection to patch panels (part of)
7952   // Removed; do not contribute much; put into ring structure
7953   /*
7954   TGeoPcon* ssdcablelay6materialbudgetpconshape =
7955                                         new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7956   TGeoVolume* ssdcablelay6materialbudgetpcon;
7957   Double_t ssdcablelay6materialbudgetpconrmin[2];
7958   Double_t ssdcablelay6materialbudgetpconrmax[2];
7959   Double_t ssdcablelay6materialbudgetpconzsection[2];
7960   ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7961                                                                                 + kSSDCablesLay5RightSideWaterHeight;
7962   ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7963                                                                                 + kSSDCableMaterialBudgetHeight;
7964   ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7965   ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7966   ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7967                                                                                         + fgkEndCapSupportCenterLay6Position
7968                                                                                         + ssdcablelay6rightsidelength;
7969   ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7970   for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7971                                                   ssdcablelay6materialbudgetpconzsection[i],
7972                                                   ssdcablelay6materialbudgetpconrmin[i],
7973                                                   ssdcablelay6materialbudgetpconrmax[i]);
7974   ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7975                                                            ssdcablelay6materialbudgetpconshape,fSSDCopper);
7976   ssdcablelay6materialbudgetpcon->SetLineColor(9);
7977   for(Int_t i=0; i<4; i++){
7978    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7979    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7980   }
7981   */
7982 ////////////////////////////////////
7983  /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7984   cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7985   Double_t ssdcablesvolume = 0.0;
7986   for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7987   std::cout << ssdcablesvolume << std::endl;*/
7988   // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
7989   return ssdcablesmother;
7990  }
7991  ////////////////////////////////////////////////////////////////////////////////
7992 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
7993                                             Double_t height, const char* shapename, Int_t isign) const{
7994   /////////////////////////////////////////////////////////////
7995   // Method generating an Arb shape
7996   /////////////////////////////////////////////////////////////
7997   const Int_t kvertexnumber = 8;
7998   const Int_t ktransvectnumber = 2;
7999   TVector3 vertex[kvertexnumber];
8000   TVector3 transvector[2];
8001   for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
8002   /////////////////////////////////////////////////////////////
8003   //Setting the vertices for TGeoArb8
8004   /////////////////////////////////////////////////////////////
8005   vertex[0] = *vertexpos[0];
8006   vertex[1] = *vertexpos[1];
8007   vertex[2] = vertex[1];
8008   vertex[3] = vertex[0];
8009   vertex[4] = *vertexpos[2];
8010   vertex[5] = *vertexpos[3];
8011   vertex[6] = vertex[5];
8012   vertex[7] = vertex[4];
8013
8014   // NB: order of points is clockwise
8015   if (isign < 0) {
8016     vertex[2] -= transvector[0];
8017     vertex[3] -= transvector[0];
8018     vertex[6] -= transvector[1];
8019     vertex[7] -= transvector[1];
8020   }
8021   else {
8022     vertex[0] += transvector[0];
8023     vertex[1] += transvector[0];
8024     vertex[4] += transvector[1];
8025     vertex[5] += transvector[1];
8026   }
8027
8028   /////////////////////////////////////////////////////////////
8029   TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8030   for(Int_t i = 0; i<kvertexnumber;i++) {
8031     arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8032   }
8033
8034   return arbshape;
8035 }
8036 ///////////////////////////////////////////////////////////////////////////////
8037 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8038                                                                 Double_t rmax, Int_t nedges, Double_t height){
8039   /////////////////////////////////////////////////////////////
8040   // Method generating Arc shape
8041   /////////////////////////////////////////////////////////////
8042         const Int_t kvertexnumber = 2*nedges+2;
8043         TGeoXtru* arcshape = new TGeoXtru(2);
8044         TVector3** vertexposition[2];
8045         for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8046         Double_t angle = 0.;
8047     for(Int_t i=0; i<nedges+1; i++){
8048                 angle = 90.+0.5*phi-i*(phi/nedges);
8049                 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle),0);
8050                 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle),0);
8051         }
8052         Double_t *xvertexpoints = new Double_t[kvertexnumber];
8053         Double_t *yvertexpoints = new Double_t[kvertexnumber];
8054         for(Int_t i=0; i<kvertexnumber; i++){
8055                 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8056                                   yvertexpoints[i] = vertexposition[0][i]->Y();
8057                 }
8058                 else if(i>=1&&i<nedges+2)
8059                 {
8060                         xvertexpoints[i] = vertexposition[1][i-1]->X();
8061                         yvertexpoints[i] = vertexposition[1][i-1]->Y();
8062                 }
8063         else
8064                 {
8065                         xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8066                         yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8067                 }
8068     }
8069   arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8070   arcshape->DefineSection(0,-0.5*height);
8071   arcshape->DefineSection(1,0.5*height);
8072   /////////////////////////////////////////////////////////////
8073   // Deallocating memory
8074   /////////////////////////////////////////////////////////////
8075   for(Int_t i=0; i<2; i++){
8076         for(Int_t j=0; j<nedges+1; j++)
8077                 delete vertexposition[i][j];
8078         delete [] vertexposition[i];
8079   }
8080   delete [] xvertexpoints;
8081   delete [] yvertexpoints;
8082   /////////////////////////////////////////////////////////////
8083         return arcshape;
8084 }
8085 ////////////////////////////////////////////////////////////////////////////////
8086 TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
8087   ///////////////////////////////////////////////////////////////////////
8088   // Method Generating the Screw Shape
8089   // radius[0]: outer radius
8090   // radius[1]: inner radius
8091   // edgesnumber[0]: outer number of edges
8092   // edgesnumber[1]: inner number of edges
8093   // section[0]: lower section position
8094   // section[1]: higher section position
8095   ///////////////////////////////////////////////////////////////////////
8096   Double_t outradius = radius[0];
8097   Double_t inradius = radius[1];
8098   Int_t outvertexnumber = edgesnumber[0];
8099   Int_t invertexnumber = edgesnumber[1];
8100   Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8101   Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8102   for(Int_t i=0; i<outvertexnumber; i++){
8103         xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8104         yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8105   }
8106   for(Int_t i=0; i<invertexnumber; i++){
8107         xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8108         yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
8109   }
8110   TGeoXtru* screwshapeout = new TGeoXtru(2);
8111   screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8112   screwshapeout->DefineSection(0,section[0]);
8113   screwshapeout->DefineSection(1,section[1]);
8114   TGeoXtru* screwshapein = new TGeoXtru(2);
8115   screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8116   screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8117   screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8118   TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8119   TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8120
8121   delete [] xscrewvertex;
8122   delete [] yscrewvertex;
8123   return screwshape;
8124 }
8125 ////////////////////////////////////////////////////////////////////////////////
8126 TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
8127   ///////////////////////////////////////////////////////////////////////
8128   // Method Generating the Hole Shape
8129   // radius of the Hole
8130   // nedges: number of edges to approximate the circle
8131   ///////////////////////////////////////////////////////////////////////
8132   Double_t* xholevertex = new Double_t[nedges];
8133   Double_t* yholevertex = new Double_t[nedges];
8134   Double_t z  = 0.5*(section[0]+section[1]);
8135   Double_t dz = 0.5*(section[1]-section[0]);
8136   TGeoTranslation *tr = 0;
8137   if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8138      tr = new TGeoTranslation(0.,0.,z);
8139      tr->RegisterYourself();
8140   }
8141   TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8142   for(Int_t i=0; i<nedges; i++){
8143         xholevertex[i] = radius*CosD(i*360./nedges);
8144         yholevertex[i] = radius*SinD(i*360./nedges);
8145   }
8146   TGeoXtru* holeshapeout = new TGeoXtru(2);
8147   holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8148   holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8149   holeshapeout->DefineSection(1,section[1]+0.01);
8150   TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8151   TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8152
8153   delete [] xholevertex;
8154   delete [] yholevertex;
8155   return holeshape;
8156 }
8157 ////////////////////////////////////////////////////////////////////////////////
8158 TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
8159   /////////////////////////////////////////////////////////////
8160   // Given an axis specified by param, it gives the reflection of the point
8161   // respect to the axis
8162   /////////////////////////////////////////////////////////////
8163   TVector3* n = new TVector3(param[0],param[1],param[2]);
8164   Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8165   TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
8166   /////////////////////////////////////////////////////////////
8167   // Deallocating memory
8168   /////////////////////////////////////////////////////////////
8169   delete n;
8170   /////////////////////////////////////////////////////////////
8171   return reflectedvector;
8172 }
8173 ////////////////////////////////////////////////////////////////////////////////
8174 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
8175                                                        Double_t dx,
8176                                                        Double_t dy,
8177                                                        Double_t dz) const{
8178   /////////////////////////////////////////////////////////////
8179   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
8180   /////////////////////////////////////////////////////////////
8181   TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8182   const Double_t *vect = hmatrix->GetTranslation();
8183   Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
8184   hmatrix->SetTranslation(newvect);
8185   TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8186   delete hmatrix;
8187   return matrix;
8188 }
8189 ////////////////////////////////////////////////////////////////////////////////
8190 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
8191   /////////////////////////////////////////////////////////////
8192   // Method returning the Medium type
8193   /////////////////////////////////////////////////////////////
8194   char ch[100];
8195   snprintf(ch,100, "ITS_%s",mediumName);
8196   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
8197   if (! medium)
8198     AliError(Form("medium %s not found !\n", mediumName));
8199   return medium;
8200 }
8201 ////////////////////////////////////////////////////////////////////////////////
8202 void AliITSv11GeometrySSD::CreateMaterials(){
8203 ///////////////////////////////////
8204 // This part has to be modified
8205 ///////////////////////////////////
8206   ///////////////////////////////////
8207   // Silicon for Sensor
8208   ///////////////////////////////////
8209   fSSDSensorMedium = GetMedium("SI$");
8210   ///////////////////////////////////
8211   // Silicon Mixture for Sensor
8212   ///////////////////////////////////
8213   fSSDChipMedium = GetMedium("SPD SI CHIP$");
8214   fSSDChipGlueMedium = GetMedium("EPOXY$");
8215   ///////////////////////////////////
8216   // Stiffener Components Materials
8217   ///////////////////////////////////
8218   fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
8219   ///////////////////////////
8220   // Stiffener Connectors
8221   ///////////////////////////
8222   fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
8223   ////////////////////////////////
8224   // Stiffener 0603-1812 Capacitor
8225   ////////////////////////////////
8226   fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8227   fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8228   fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
8229   ///////////////////////////
8230   // Stiffener Hybrid Wire
8231   ///////////////////////////
8232   fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
8233   ///////////////////////////
8234   // Al for Cooling Block
8235   ///////////////////////////
8236   fSSDAlCoolBlockMedium = GetMedium("AL$");
8237   //////////////////////////////////////////////////////
8238   // Kapton and Al for Chip Cable Flex and Ladder Cables
8239   //////////////////////////////////////////////////////
8240   fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8241   fSSDAlTraceChipCableMedium = GetMedium("AL$");
8242   fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8243   fSSDAlTraceFlexMedium = GetMedium("AL$");
8244   fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8245   fSSDAlTraceLadderCableMedium = GetMedium("AL$");
8246   /////////////////////////////////////////////////////////////////
8247   // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8248   //////////////////////////////////////////////////////////////////
8249   fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
8250   /////////////////////////////////////////////////////////////////
8251   // G10 for Detector Leg, TubeHolder
8252   //////////////////////////////////////////////////////////////////
8253   fSSDTubeHolderMedium = GetMedium("G10FR4$");
8254   fSSDSensorSupportMedium = GetMedium("G10FR4$");
8255   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8256   fSSDMountingBlockMedium = GetMedium("G10FR4$");
8257   /////////////////////////////////////////////////////////////////
8258   // Water and Phynox for Cooling Tube
8259   //////////////////////////////////////////////////////////////////
8260   fSSDCoolingTubeWater = GetMedium("WATER$");
8261   fSSDCoolingTubePhynox = GetMedium("INOX$");
8262   /////////////////////////////////////////////////////////////////////
8263   // Material for Support Rings
8264   /////////////////////////////////////////////////////////////////////
8265   fSSDSupportRingAl = GetMedium("AL$");
8266   fSSDRohaCellCone = GetMedium("ROHACELL$");
8267   /////////////////////////////////////////////////////////////////////
8268   fSSDAir = GetMedium("SDD AIR$");
8269   fSSDCopper = GetMedium("COPPER$");
8270   fSSDSn = GetMedium("Sn$");
8271   fCreateMaterials = kTRUE;
8272 }
8273 /////////////////////////////////////////////////////////////////////
8274