V11 SSD geometry (E. Cattaruzza)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Mar 2007 13:41:02 +0000 (13:41 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Mar 2007 13:41:02 +0000 (13:41 +0000)
ITS/AliITSv11GeometrySSD.cxx [new file with mode: 0644]
ITS/AliITSv11GeometrySSD.h [new file with mode: 0644]
ITS/ITSsimLinkDef.h
ITS/libITSsim.pkg

diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx
new file mode 100644 (file)
index 0000000..8239600
--- /dev/null
@@ -0,0 +1,3399 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+//*************************************************************************
+// SSD geometry, based on ROOT geometrical modeler
+//
+// Enrico Cattaruzza                                    ecattar@ts.infn.it
+//*************************************************************************
+#include "TMath.h"
+#include "TGeoVolume.h"
+#include "TGeoMedium.h"
+#include "TGeoMatrix.h"
+#include <TGeoManager.h>
+#include "AliITSv11GeometrySSD.h"
+#include "TVector3.h"
+#include "TGeoArb8.h"
+#include "TList.h"
+#include "TGeoMatrix.h"
+#include "TGeoCompositeShape.h"
+#include "TGeoTube.h"
+#include "TGeoBBox.h"
+#include "TGeoTrd1.h"
+#include <iostream>
+using namespace std;
+/////////////////////////////////////////////////////////////////////////////////
+//Parameters for SSD Geometry
+/////////////////////////////////////////////////////////////////////////////////
+// Layer5 (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7;
+const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
+const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0;
+const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85;
+/////////////////////////////////////////////////////////////////////////////////
+// Layer6 (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0;
+const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
+const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0;
+const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100; 
+const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength        =   fgkSSDChipLength;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth         =   fgkSSDChipWidth;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030;
+/////////////////////////////////////////////////////////////////////////////////
+// Stiffener (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500;
+//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   =   1.600;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400;
+const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32, 0.33};
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   = 0.44;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       = 2.16;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        = 3.60;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       = 
+                                                                                                         0.25*fgkSSDStiffenerHeight;
+/////////////////////////////////////////////////////////////////////////////////
+// Cooling Block (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = 
+                                                                                                        {1.950, 0.240, 0.300};
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] = 
+                                                                                                                   {1.000, 0.120};
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] = 
+                                                                                                                       {1.900, 0.400};
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =  
+                                                                                                                                        1.500;
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =  
+                                                                                                                                        0.300;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Sensor (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       = 
+                                                          "SSDSensorSensitiveVol";
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         = 
+                                                                                                  fgkSSDSensorLength-39.1;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength      = 1.; 
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth       = 1.;
+/////////////////////////////////////////////////////////////////////////////////
+// Flex (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000; 
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        = 
+                       {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                                               +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+                        0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                                               +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000,
+                                                 9.500, 10.000};
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         = 
+                                                                                                                {  9.340,  5.380};
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
+                                                                                                                {  0.030,  0.020};      
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430;
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] = 
+                                                                                  {3.30,4.12,4.22,1.70,0.75,7.18};
+const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
+                                                                                                          {15.03,23.48,12.28};
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Ladder Cable (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =   23.5;
+const Double_t AliITSv11GeometrySSD::fgkSSDEndLadderCableLength =   50.000; /////to be modified
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Module (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  = 
+                                                                                                                  { 1.000, 3.900};
+const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =  
+                                                                                                                                       45.600;
+const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =  
+                                                                                                                                        5.075;
+/////////////////////////////////////////////////////////////////////////////////
+// Sensor Support (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                = 
+                                                                                                                                          5.800;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =  
+                                                                                                                                          2.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
+                                                                                                                    { 4.620, 5.180};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = 
+                                                                                                                    { 0.450, 0.450};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition       =  
+                                                                         0.5*(fgkSSDModuleSensorSupportDistance
+                                                              +    fgkSSDSensorSideSupportThickness[0])
+                                                                  -           fgkSSDSensorSideSupportLength;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength      =  
+                                                                                                                                          5.250;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
+                                                                                                                                      1.680;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]    =
+          {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
+          fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
+   {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     = 
+                                                                                                                                     19.000;
+/////////////////////////////////////////////////////////////////////////////////
+// Chip Cables (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   = 
+                                                {73.12/fgkSSDChipNumber,fgkSSDChipLength+2.*0.19};
+const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   = 
+                                               {  0.014,  0.010, fgkSSDModuleCoolingBlockToSensor
+  -  (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
+  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
+  -   fgkSSDChipHeight-fgkSSDSensorHeight,
+      fgkSSDModuleCoolingBlockToSensor
+  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
+  -   fgkSSDChipHeight-fgkSSDSensorHeight};
+const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    = 
+                                                                                                { 11.000,  0.800,  0.600};
+/////////////////////////////////////////////////////////////////////////////////
+// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
+                                                                                                                                          3.820;
+//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
+//                                                                                                                                        3.780;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           = 
+                                                                         fgkSSDSensorLength-fgkSSDSensorOverlap;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         = 
+                                                                                                                        {  0.86,  0.30};
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        = 
+                                                                                                                        { 30.00, 90.00};
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport = 
+                                                                                                                                           1.78;
+/////////////////////////////////////////////////////////////////////////////////
+//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength          = 
+  fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;  
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle           = 
+                                                                                                                                          60.00;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   = 
+                                                                                                                  {  0.751,  0.482};
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength       =  
+                                                                                                                                          1.630;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth            = 
+                                                                                                                                          0.950;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength      = 
+            fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
+                    / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength      = 
+                                 0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
+                        - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
+/////////////////////////////////////////////////////////////////////////////////
+// Carbon Fiber Lower Support Parameters (lengths are in mm)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth             
+                                                                                                                                         =  0.950;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght       
+                                                                                                                                         =  1.600;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight            
+                                                                                                                                         =  0.830;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation  
+                                                                                         = 0.5*fgkCarbonFiberSupportWidth;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth   
+                                                                = fgkCarbonFiberJunctionWidth
+                                 - 2.*(fgkCarbonFiberLowerSupportWidth
+                                                                + fgkCarbonFiberLowerSupportVolumeSeparation);
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2] 
+                                                                = {fgkCarbonFiberLowerSupportWidth
+                                                                +  fgkCarbonFiberLowerSupportVolumeSeparation,
+                                                                       fgkCarbonFiberLowerSupportWidth
+                                                                +  fgkCarbonFiberLowerSupportVolumeSeparation                                                  
+                                                                +  fgkCarbonFiberLowerSupportTransverseWidth};
+/////////////////////////////////////////////////////////////////////////////////
+// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] = 
+  {0.5*(fgkSSDLay5LadderLength
+         -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
+         -fgkCarbonFiberLowerSupportWidth),
+       0.5*(fgkSSDLay5LadderLength
+         -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
+         +fgkCarbonFiberLowerSupportWidth)};
+const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] = 
+               {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4,
+                fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6};
+const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] = 
+                                                  {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50,
+                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50};
+/////////////////////////////////////////////////////////////////////////////////
+// Cooling Tube Support (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax          =  1.45;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin          
+                                                                                         = fgkSSDCoolingBlockHoleRadius[0];
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength        =  8.55;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight        =  0.85;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth         =  2.00;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    = 
+                                      fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70;
+/////////////////////////////////////////////////////////////////////////////////
+// Cooling Tube (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax       = 
+                                                                                                         fgkCoolingTubeSupportRmin;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin       =  0.96;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength     = 
+                                                                                                       fgkCarbonFiberJunctionWidth;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation = 
+                                       fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
+//const Double_t AliITSv11GeometrySSD_ct::fgkCoolingTubeLength               =  39.1;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            = 
+                                                                                                                       { 60.0, 42.2, 34.0};
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
+                                                                                                         {  4.0,  8.0,  5.0,  0.2};
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =   
+                                                                                                                                                  20.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =   
+                                                                                                                                                  40.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  = 
+                  0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =    
+                                                                                                                                                       2.5;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    = 
+                                                                                                                                 { 56.0, 12.0}; 
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     = 
+                                                                                                                                 {  5.0,  2.9}; 
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           = 
+                                                                                                                                                       1.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =   
+                                                                                                                                                       6.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =  
+                                                                                                                                                       4.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
+                                                                       {  1.5,fgkSSDMountingBlockScrewHoleEdge/6.};
+/////////////////////////////////////////////////////////////////////////////////
+AliITSv11GeometrySSD::AliITSv11GeometrySSD(){           
+  ///////////////////////////////// 
+  // Standard Default Constructor
+  ///////////////////////////////// 
+  // Initializing display colors  
+  ////////////////////////////// 
+  fColorCarbonFiber =  4;
+  fColorRyton       =  5;
+  fColorPhynox      =  5;
+  fColorSilicon     =  3;
+  fColorAl          =  7;
+  fColorKapton      =  6;
+  fColorPolyhamide  =  5;
+  fColorStiffener   =  9;
+  fColorEpoxy       = 30;
+  CreateMaterials();
+}
+/////////////////////////////////////////////////////////////////////////////////
+// Setting the transformation Matrices
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
+  ////////////////////////////////////////////////////////
+  //Translation Parameters SSDSensorSupportAssembly:
+  ////////////////////////////////////////////////////////
+  const Double_t SSDSensorSupportTransX[3] = {-0.5*fgkSSDSensorSideSupportWidth,
+                                                                  0.5*fgkSSDSensorSideSupportWidth,
+                                                          0.5*fgkSSDSensorCenterSupportThickness[0]
+                                                                         -    fgkSSDSensorCenterSupportPosition}; 
+  const Double_t SSDSensorSupportTransY[3] = 
+                                                                          {0.5*fgkSSDSensorSideSupportThickness[0],
+                                                          -0.5*fgkSSDSensorSideSupportThickness[0]
+                                                              -fgkSSDModuleSensorSupportDistance,
+                                                           0.5*fgkSSDSensorCenterSupportWidth
+                                                                          -0.5*fgkSSDModuleSensorSupportDistance}; 
+  const Double_t SSDSensorSupportTransZ[3] = {0.,0.,
+                                                                               fgkSSDSensorCenterSupportThickness[0]}; 
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters SSDSensorSupportAssembly:
+  ////////////////////////////////////////////////////////  
+  const Double_t SSDSensorSupportRotPhi[3]   = {   0., 180., 270.};
+  const Double_t SSDSensorSupportRotTheta[3] = {  90.,  90.,  90.};
+  const Double_t SSDSensorSupportRotPsi[3]   = {- 90.,- 90.,- 90.};
+  ////////////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
+  ////////////////////////////////////////////////////////////////
+  char SSDSensorSupportCombiTransName[40];
+  char SSDSensorSupportRotName[40];
+  TGeoCombiTrans *SSDSensorSupportLocalMatrix[fgkSSDSensorSupportCombiTransNumber];
+  for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){ 
+               sprintf(SSDSensorSupportCombiTransName,"SSDSensorSupportCombiTrans%i",i);
+               sprintf(SSDSensorSupportRotName,"SSDSensorSupportRot%i",i);
+               SSDSensorSupportLocalMatrix[i] =
+                                new TGeoCombiTrans(SSDSensorSupportCombiTransName,
+                                                                       SSDSensorSupportTransX[i],
+                                                                       SSDSensorSupportTransY[i],
+                                                                       SSDSensorSupportTransZ[i],
+                                                                       new TGeoRotation(SSDSensorSupportRotName,
+                                                                                                         SSDSensorSupportRotPhi[i],
+                                                                                                       SSDSensorSupportRotTheta[i],
+                                                                                                   SSDSensorSupportRotPsi[i]));
+           SSDSensorSupportCombiTransMatrix[i] = SSDSensorSupportLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
+/////////////////////////////////////////////////////////////////////////////////
+//Translation Parameters SSDModuleAssembly:
+////////////////////////////////////////////////////////
+  const Double_t SSDModuleTransX[7] = {0.5*fgkSSDStiffenerLength,
+                                                0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
+                                      - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
+                                          * fgkSSDChipSeparationLength)),
+                                      - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
+                                  0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
+                                          -       (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+                               0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
+                          - fgkSSDCoolingBlockLength,
+                               0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
+                          + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
+                               0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                          +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)}; 
+  const Double_t SSDModuleTransY[7] = {0.5*fgkSSDStiffenerWidth,
+                                      0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
+                                        - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
+                                    - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
+                                      fgkSSDStiffenerWidth,
+                                      0.,
+                                      fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+                                        - fgkSSDStiffenerWidth
+                                    + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
+                                      fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+                                        - fgkSSDStiffenerWidth}; 
+  const Double_t SSDModuleTransZ[7] = {0.5*fgkSSDStiffenerHeight,
+                                    - 0.5*fgkSSDChipHeight,
+                                      0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
+                                        - SSDChipCablesHeigth,
+                                    - 0.5*fgkSSDFlexHeight[0],
+                                      fgkSSDStiffenerHeight,
+                                    - fgkSSDChipHeight,
+                                    - 0.5*fgkSSDChipHeight}; 
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters SSDModuleAssembly:
+  ////////////////////////////////////////////////////////  
+  const Double_t SSDModuleRotPhi[7]   = {   0.,   0.,  90.,   0.,   0.,  90., 180.};
+  const Double_t SSDModuleRotTheta[7] = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
+  const Double_t SSDModuleRotPsi[7]   = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
+  ////////////////////////////////////////////////////////  
+  //Name of CombiTrans Transformation of SSDModuleAssembly:
+  ////////////////////////////////////////////////////////  
+  const char* SSDModuleCombiTransName[7] = {"SSDStiffenerCombiTrans",
+                                                                                            "SSDChipCombiTrans",
+                                                                                          "SSDSensorCombiTrans",
+                                                                                           "SSDFlex0CombiTrans",
+                                                                                "SSDCoolingBlockCombiTrans",
+                                                                                  "SSDChipCablesCombiTrans",
+                                                                                       "SSDFlex1CombiTrans"};
+  const char* SSDModuleRotName[7] = {"SSDStiffenerRotName",
+                                                                                 "SSDChipRotName",
+                                                                               "SSDSensorRotName",
+                                                                                "SSDFlex0RotName",
+                                                                 "SSDCoolingBlockRotName",
+                                                                       "SSDChipCablesRotName",
+                                                                               "SSDFlex1RotName"};
+  TGeoCombiTrans *SSDModuleLocalMatrix[fgkSSDModuleCombiTransNumber];
+  for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){ 
+                                       SSDModuleLocalMatrix[i] =
+                                       new TGeoCombiTrans(SSDModuleCombiTransName[i],
+                                                                          SSDModuleTransX[i],
+                                                                          SSDModuleTransY[i],
+                                                                          SSDModuleTransZ[i],
+                                                                          new TGeoRotation(SSDModuleRotName[i],
+                                                                                                               SSDModuleRotPhi[i],
+                                                                                                       SSDModuleRotTheta[i],
+                                                                                                       SSDModuleRotPsi[i]));
+    SSDModuleCombiTransMatrix[i] = SSDModuleLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
+/////////////////////////////////////////////////////////////////////////////////
+  //Translation Parameters CarbonFiberJunction:
+  ////////////////////////////////////////////////////////
+  const Double_t CarbonFiberJunctionTransX[3] = 
+                               {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
+                                * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+  const Double_t CarbonFiberJunctionTransY[3] = 
+                                                                         {  0.0, 0.0,fgkCarbonFiberTriangleLength
+                                *   TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+  const Double_t CarbonFiberJunctionTransZ[3] = {  0.0,  0.0,  0.0};
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters CarbonFiberJunction:
+  ////////////////////////////////////////////////////////
+  const Double_t CarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
+  const Double_t CarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
+  const Double_t CarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
+  ///////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of CarbonFiberJunction:
+  ///////////////////////////////////////////////////////////
+  char CarbonFiberJunctionCombiTransName[40];
+  char CarbonFiberJunctionRotName[40];
+  TGeoCombiTrans *CarbonFiberJunctionLocalMatrix[fgkCarbonFiberJunctionCombiTransNumber];
+  for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
+               sprintf(CarbonFiberJunctionCombiTransName,"CarbonFiberJunctionCombiTrans%i",i);
+               sprintf(CarbonFiberJunctionRotName,"CarbonFiberJunctionRot%i",i);
+               CarbonFiberJunctionLocalMatrix[i] =
+                                       new TGeoCombiTrans(CarbonFiberJunctionCombiTransName,
+                                                                          CarbonFiberJunctionTransX[i],
+                                                                          CarbonFiberJunctionTransY[i],
+                                                                          CarbonFiberJunctionTransZ[i],
+                                                               new TGeoRotation(CarbonFiberJunctionRotName,
+                                                                                               CarbonFiberJunctionRotPhi[i],
+                                                                                               CarbonFiberJunctionRotTheta[i],
+                                                                                               CarbonFiberJunctionRotPsi[i]));
+    CarbonFiberJunctionCombiTransMatrix[i] = CarbonFiberJunctionLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
+/////////////////////////////////////////////////////////////////////////////////
+  //Translation Parameters EndLadderCarbonFiberJunction:
+  ////////////////////////////////////////////////////////
+  const Double_t EndLadderCarbonFiberJunctionTransX[3] = 
+                               {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
+               *            TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+  const Double_t EndLadderCarbonFiberJunctionTransY[3] = 
+                                                                               {  0.0, 0.0,fgkCarbonFiberTriangleLength
+               *            TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+  const Double_t EndLadderCarbonFiberJunctionTransZ[3] = {  0.0,  0.0,  
+                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
+                                                          -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters EndLadderCarbonFiberJunction:
+  ////////////////////////////////////////////////////////
+  const Double_t EndLadderCarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
+  const Double_t EndLadderCarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
+  const Double_t EndLadderCarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
+  ///////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of CarbonFiberJunction:
+  ///////////////////////////////////////////////////////////
+  char EndLadderCarbonFiberJunctionCombiTransName[40];
+  char EndLadderCarbonFiberJunctionRotName[40];
+  TGeoCombiTrans *EndLadderCarbonFiberJunctionLocalMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
+  for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
+       sprintf(EndLadderCarbonFiberJunctionCombiTransName,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
+       sprintf(EndLadderCarbonFiberJunctionRotName,"EndLadderCarbonFiberJunctionRot%i",i);
+       EndLadderCarbonFiberJunctionLocalMatrix[i] =
+       new TGeoCombiTrans(EndLadderCarbonFiberJunctionCombiTransName,
+                                                                                 EndLadderCarbonFiberJunctionTransX[i],
+                                                                                 EndLadderCarbonFiberJunctionTransY[i],
+                                                                                 EndLadderCarbonFiberJunctionTransZ[i],
+                                               new TGeoRotation(EndLadderCarbonFiberJunctionRotName,
+                                                                                 EndLadderCarbonFiberJunctionRotPhi[i],
+                                                                               EndLadderCarbonFiberJunctionRotTheta[i],
+                                                                           EndLadderCarbonFiberJunctionRotPsi[i]));
+    EndLadderCarbonFiberJunctionCombiTransMatrix[i] = 
+                                                                        EndLadderCarbonFiberJunctionLocalMatrix[i];
+  }
+}
+////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
+/////////////////////////////////////////////////////////////////////////////////
+  //Translation Parameters CarbonFiberAssembly:
+  ////////////////////////////////////////////////////////
+  const Double_t CarbonFiberAssemblyTransX[3] = {  0.0,  0.0,  0.0};
+  const Double_t CarbonFiberAssemblyTransY[3] = 
+                                                                               {  0.5*fgkCarbonFiberJunctionWidth, 0.0, 
+                                       fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
+                          -    fgkCarbonFiberLowerSupportVolumePosition[0]
+                          -    fgkCarbonFiberLowerSupportVolumePosition[1]};
+  const Double_t CarbonFiberAssemblyTransZ[3] = 
+                                                 {  0.0,  0.0,-  0.5*fgkCarbonFiberLowerSupportHeight};
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters CarbonFiberAssembly:
+  ////////////////////////////////////////////////////////
+  const Double_t CarbonFiberAssemblyRotPhi[3]   = {   0.,  90.,   0.};
+  const Double_t CarbonFiberAssemblyRotTheta[3] = {  90.,
+                                                                                       -fgkCarbonFiberTriangleAngle,   0.};
+  const Double_t CarbonFiberAssemblyRotPsi[3]   = {   0.,- 90.,   0.};
+  ///////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of CarbonFiberAssembly:
+  ///////////////////////////////////////////////////////////
+  char CarbonFiberAssemblyCombiTransName[30];
+  char CarbonFiberAssemblyRotName[30];
+  TGeoCombiTrans *CarbonFiberAssemblyLocalMatrix[fgkCarbonFiberAssemblyCombiTransNumber];
+  for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
+       sprintf(CarbonFiberAssemblyCombiTransName,"CarbonFiberAssemblyCombiTrans%i",i);
+       sprintf(CarbonFiberAssemblyRotName,"CarbonFiberAssemblyRot%i",i);
+       CarbonFiberAssemblyLocalMatrix[i] =
+                                               new TGeoCombiTrans(CarbonFiberAssemblyCombiTransName,
+                                                                                  CarbonFiberAssemblyTransX[i],
+                                                                                  CarbonFiberAssemblyTransY[i],
+                                                                                  CarbonFiberAssemblyTransZ[i],
+                                                new TGeoRotation(CarbonFiberAssemblyRotName,
+                                                                                  CarbonFiberAssemblyRotPhi[i],
+                                                                                  CarbonFiberAssemblyRotTheta[i],
+                                                                                  CarbonFiberAssemblyRotPsi[i]));
+    CarbonFiberAssemblyCombiTransMatrix[i] = CarbonFiberAssemblyLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
+  ////////////////////////////////////////////////////////
+  //Translation Parameters CoolingTubeSupport:
+  ////////////////////////////////////////////////////////
+  Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
+                                                                                                       /fgkCoolingTubeSupportRmax);
+  const Double_t CoolingTubeSupportTransX[2] = 
+                                                 {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(Phi)
+                                               +  2.*(fgkCoolingTubeSupportLength
+                                               -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(Phi)))
+                                               +  fgkCarbonFiberTriangleLength
+                                               -  2.0*fgkCarbonFiberJunctionLength};
+  const Double_t CoolingTubeSupportTransY[2] = {  0.0,  0.0};
+  const Double_t CoolingTubeSupportTransZ[2] = {  0.0,  0.0};
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters CoolingTubeSupport:
+  ////////////////////////////////////////////////////////
+  const Double_t CoolingTubeSupportRotPhi[2]   = {   0., 180.};
+  const Double_t CoolingTubeSupportRotTheta[2] = {   0.,   0.};
+  const Double_t CoolingTubeSupportRotPsi[2]   = {   0.,   0.};
+  ///////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of CarbonFiberJunction:
+  ///////////////////////////////////////////////////////////
+  char CoolingTubeSupportCombiTransName[40];
+  char CoolingTubeSupportRotName[40];
+  TGeoCombiTrans *CoolingTubeSupportLocalMatrix[fgkCoolingTubeSupportCombiTransNumber];
+  for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
+       sprintf(CoolingTubeSupportCombiTransName,"CoolingTubeSupportCombiTrans%i",i);
+       sprintf(CoolingTubeSupportRotName,"CoolingTubeSupportRot%i",i);
+       CoolingTubeSupportLocalMatrix[i] =
+                       new TGeoCombiTrans(CoolingTubeSupportCombiTransName,
+                                                          CoolingTubeSupportTransX[i],
+                                                          CoolingTubeSupportTransY[i],
+                                                          CoolingTubeSupportTransZ[i],
+                                                          new TGeoRotation(CoolingTubeSupportRotName,
+                                                                                               CoolingTubeSupportRotPhi[i],
+                                                                                               CoolingTubeSupportRotTheta[i],
+                                                                                               CoolingTubeSupportRotPsi[i]));
+    CoolingTubeSupportCombiTransMatrix[i] = CoolingTubeSupportLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
+  ////////////////////////////////////////////////////////
+  //Translation Parameters CoolingTube:
+  ////////////////////////////////////////////////////////
+  const Double_t CoolingTubeTransX[2] = {  0.,  fgkCoolingTubeSeparation};
+  const Double_t CoolingTubeTransY[2] = {  fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
+  const Double_t CoolingTubeTransZ[2] = {  0.0,  0.};
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters CoolingTube:
+  ////////////////////////////////////////////////////////
+  const Double_t CoolingTubeRotPhi[2]   = {   0.,   0.};
+  const Double_t CoolingTubeRotTheta[2] = {  90.,  90.};
+  const Double_t CoolingTubeRotPsi[2]   = {   0.,   0.};
+  ///////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of CarbonFiberJunction:
+  ///////////////////////////////////////////////////////////
+  const char* CoolingTubeCombiTransName[fgkCoolingTubeCombiTransNumber] = 
+                                                       {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
+  const char* CoolingTubeRorationName[fgkCoolingTubeCombiTransNumber] = 
+                                                               {"CoolingTubeRotation0","CoolingTubeRotation1"};
+  TGeoCombiTrans *CoolingTubeLocalMatrix[fgkCoolingTubeCombiTransNumber];
+  for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
+       CoolingTubeLocalMatrix[i] =
+                       new TGeoCombiTrans(CoolingTubeCombiTransName[i],
+                                                          CoolingTubeTransX[i],
+                                                          CoolingTubeTransY[i],
+                                                          CoolingTubeTransZ[i], 
+                                                          new TGeoRotation(CoolingTubeRorationName[i],
+                                                                           CoolingTubeRotPhi[i],
+                                                                           CoolingTubeRotTheta[i],
+                                                                           CoolingTubeRotPsi[i]    ) );
+    CoolingTubeTransMatrix[i] = CoolingTubeLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
+/////////////////////////////////////////////////////////////////////////////////
+  //Translation Parameters LadderSegment:
+  ////////////////////////////////////////////////////////
+       const Double_t LadderSegmentTransX[fgkLadderSegmentCombiTransNumber] = {  0.,
+        -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
+                        fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
+                        fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
+        -       fgkCoolingTubeSupportRmax),
+               0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)}; 
+       const Double_t LadderSegmentTransY[fgkLadderSegmentCombiTransNumber] = {  0.,
+        -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                        fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+        +               0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+        -               0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+        -            fgkSSDSensorCenterSupportThickness[0]),
+                                 fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
+        +            fgkSSDSensorCenterSupportLength
+        -            fgkSSDSensorCenterSupportThickness[0])
+        -                        fgkSSDSensorCenterSupportPosition,
+                                 fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
+        -                        fgkCoolingTubeSupportToCarbonFiber,
+                                                                                                0.0};
+       const Double_t LadderSegmentTransZ[fgkLadderSegmentCombiTransNumber] = {  0.,
+        -        (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
+        -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
+                                                                                                                                                        0.,
+        -     0.5*fgkCoolingTubeSupportHeight,
+        -     0.5*fgkCoolingTubeSupportHeight};
+//////////////////////////////////////////////////
+  //Rotational Parameters LadderSegment:
+  ////////////////////////////////////////////////////////
+  const Double_t LadderSegmentRotPhi[fgkLadderSegmentCombiTransNumber]   =
+                                                                                                         {   0.,   0.,- 90.,   0.,  0.};
+  const Double_t LadderSegmentRotTheta[fgkLadderSegmentCombiTransNumber] = 
+                                                                                                         {   0.,   0.,   0.,  90.,  0.};
+  const Double_t LadderSegmentRotPsi[fgkLadderSegmentCombiTransNumber]   = 
+                                                                                                         {   0.,   0.,   0.,   0.,  0.};
+  //////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of LadderSegment:
+  //////////////////////////////////////////////////////
+  char LadderSegmentCombiTransName[40];
+  char LadderSegmentRotName[40];
+  TGeoCombiTrans *LadderSegmentLocalMatrix[fgkLadderSegmentCombiTransNumber];
+  for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
+               sprintf(LadderSegmentCombiTransName,"LadderSegmentCombiTrans%i",i);
+               sprintf(LadderSegmentRotName,"LadderSegmentRot%i",i);
+               LadderSegmentLocalMatrix[i] =
+                                       new TGeoCombiTrans(LadderSegmentCombiTransName,
+                                                                          LadderSegmentTransX[i],
+                                                                          LadderSegmentTransY[i],
+                                                                          LadderSegmentTransZ[i],
+                                                                          new TGeoRotation(LadderSegmentRotName,
+                                                                                                               LadderSegmentRotPhi[i],
+                                                                                                               LadderSegmentRotTheta[i],
+                                                                                                               LadderSegmentRotPsi[i]));
+    LadderSegmentCombiTransMatrix[i] = LadderSegmentLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
+/////////////////////////////////////////////////////////////////////////////////
+  //Translation Parameters EndLadderSegment:
+  ////////////////////////////////////////////////////////
+  const Double_t EndLadderSegmentTransX[4] = {0.0,
+                                                                                         0.0,
+                -  0.25*(fgkSSDMountingBlockLength[0]
+                        +      fgkSSDMountingBlockLength[1])
+                        +  0.5*fgkCarbonFiberTriangleLength,
+                                                                                         0.0}; 
+  const Double_t EndLadderSegmentTransY[4] = 
+                                                        {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
+                                                 i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
+                                                        fgkEndLadderMountingBlockPosition[i],
+                                                  (1-i)*(fgkEndLadderMountingBlockPosition[i]
+                                                                                +  0.5*fgkSSDMountingBlockWidth)}; 
+  const Double_t EndLadderSegmentTransZ[4] = {0.0,
+                                                                                         0.0,
+                                                                               -  fgkSSDMountingBlockHeight[1]
+                                                                               +  0.5*fgkSSDMountingBlockHeight[0],
+                                                                           -  0.5*fgkCarbonFiberLowerSupportHeight}; 
+  ////////////////////////////////////////////////////////
+  //Rotational Parameters EndLadderSegment:
+  ////////////////////////////////////////////////////////  
+  const Double_t EndLadderSegmentRotPhi[4]   = {   0.,  90.,   0.,   0.};
+  const Double_t EndLadderSegmentRotTheta[4] = {  90.,-fgkCarbonFiberTriangleAngle,
+                                                                                                  0.,   0.};
+  const Double_t EndLadderSegmentRotPsi[4]   = {   0.,- 90.,   0.,   0.};
+  ////////////////////////////////////////////////////////
+  //Name of CombiTrans Transformation of EndLadderSegment:
+  ////////////////////////////////////////////////////////
+  char EndLadderSegmentCombiTransName[30];
+  char EndLadderSegmentRotName[30];
+  TGeoCombiTrans *EndLadderSegmentLocalMatrix[fgkEndLadderSegmentCombiTransNumber];
+  for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){ 
+               sprintf(EndLadderSegmentCombiTransName,"EndLadderSegmentCombiTrans%i",i);
+               sprintf(EndLadderSegmentRotName,"EndLadderSegmentRot%i",i);
+               EndLadderSegmentLocalMatrix[i] =
+                               new TGeoCombiTrans(EndLadderSegmentCombiTransName,
+                                                                  EndLadderSegmentTransX[i],
+                                                                  EndLadderSegmentTransY[i],
+                                                                  EndLadderSegmentTransZ[i],
+                                                                  new TGeoRotation(EndLadderSegmentRotName,
+                                                                                                       EndLadderSegmentRotPhi[i],
+                                                                                                       EndLadderSegmentRotTheta[i],
+                                                                                                       EndLadderSegmentRotPsi[i]));
+    EndLadderSegmentCombiTransMatrix[i] = EndLadderSegmentLocalMatrix[i];
+  }
+}
+/////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
+////////////////////////////////////////////////////////////////////////////////
+// Translation Parameters for LadderCable
+/////////////////////////////////////////
+  Double_t SSDFlexRadius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
+                                            + fgkSSDFlexHeight[1];  
+  Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
+                                                       /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
+  Double_t SSDLadderCableTransX[3];
+  SSDLadderCableTransX[0] = (SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
+                                                 *   TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
+                                                 *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
+  SSDLadderCableTransX[1] = ((SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
+                                                 -     SSDLadderCableTransX[0]
+                                                 /     TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
+                                                 *     TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());                                          
+  SSDLadderCableTransX[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+                                                 *       TMath::DegToRad()*SSDFlexRadiusMax
+                                                 -     fgkSSDFlexLength[2]-TMath::Pi()
+                                                 *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
+                                                 -       fgkSSDLadderCableWidth)
+                                                 *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
+  Double_t SSDLadderCableTransZ[3] = {SSDLadderCableTransX[0]
+                                                 *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
+                                                       SSDLadderCableTransX[1]
+                                                 *     TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
+                                                       SSDLadderCableTransX[2]
+                                                 *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};      
+  TGeoRotation* LocalLadderCableRot[3];        
+  LocalLadderCableRot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
+  LocalLadderCableRot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
+  LocalLadderCableRot[2] = new TGeoRotation("LocalLadderCableRot2");
+  LocalLadderCableRot[2]->SetRotation((*LocalLadderCableRot[1])
+                                                *                        (*LocalLadderCableRot[0]));
+////////////////////////////////////////////
+// LocalLadderCableCombiTransMatrix
+////////////////////////////////////////////
+  const Int_t LocalLadderSideCablesNumber = 2;
+  const Int_t LocalLadderCombiTransNumber = 5;
+  TGeoCombiTrans** LocalLadderCableCombiTransMatrix[LocalLadderSideCablesNumber];
+  for(Int_t i=0; i<LocalLadderSideCablesNumber; i++) 
+       LocalLadderCableCombiTransMatrix[i] = 
+                                                          new TGeoCombiTrans*[LocalLadderCombiTransNumber];
+///////////////////////////////////////////
+// Left Side Ladder Cables Transformations
+///////////////////////////////////////////
+  LocalLadderCableCombiTransMatrix[0][0]  =
+                                               new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
+                                               0.,0.,NULL);
+  LocalLadderCableCombiTransMatrix[0][1] = LadderSegmentCombiTransMatrix[1];
+  LocalLadderCableCombiTransMatrix[0][2] = 
+                                               new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
+                                                                                  fgkSSDModuleStiffenerPosition[1],0.,0);
+  LocalLadderCableCombiTransMatrix[0][3] = SSDModuleCombiTransMatrix[6];
+  LocalLadderCableCombiTransMatrix[0][4] = 
+                                               new TGeoCombiTrans(-SSDLadderCableTransX[0]
+                                               -     SSDLadderCableTransX[1]-SSDLadderCableTransX[2]
+                                               +     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
+                                                         0.,
+                                                         0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
+                                               +         fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
+                                               +     SSDLadderCableTransZ[0]-SSDLadderCableTransZ[1]
+                                               +         SSDLadderCableTransZ[2],LocalLadderCableRot[2]);
+///////////////////////////////////////////
+// Rigth Side Ladder Cables Transformations
+///////////////////////////////////////////
+ for(Int_t i=0; i<LocalLadderCombiTransNumber; i++)
+   LocalLadderCableCombiTransMatrix[1][i] = 
+                       (i!=3 ? LocalLadderCableCombiTransMatrix[0][i]:
+                                       SSDModuleCombiTransMatrix[3]);  
+///////////////////////////////////////////
+// Setting LadderCableCombiTransMatrix
+///////////////////////////////////////////
+Int_t BeamAxisTrans[3] = {0,0,0};
+switch(iLayer){
+case 5: 
+       BeamAxisTrans[0] = fgkSSDLay5SensorsNumber/2;
+       BeamAxisTrans[1] = BeamAxisTrans[0]+1;
+       BeamAxisTrans[2] = BeamAxisTrans[0]-1;
+       break;
+case 6:
+       BeamAxisTrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
+       BeamAxisTrans[1] = BeamAxisTrans[0]+1;
+       BeamAxisTrans[2] = BeamAxisTrans[0];
+       break;
+}
+ TGeoHMatrix* LocalLadderCableHMatrix[LocalLadderSideCablesNumber];
+ TGeoRotation* LadderCableRot;
+ TGeoTranslation* LadderCableTrans;
+ for(Int_t i=0; i<LocalLadderSideCablesNumber; i++){
+       LocalLadderCableHMatrix[i] = new TGeoHMatrix();
+       for(Int_t j=0; j<LocalLadderCombiTransNumber; j++){
+                 LocalLadderCableHMatrix[i]->MultiplyLeft(
+                 LocalLadderCableCombiTransMatrix[i][LocalLadderCombiTransNumber-j-1]);
+       }
+       LadderCableRot = new TGeoRotation();
+       LadderCableRot->SetMatrix(LocalLadderCableHMatrix[i]->GetRotationMatrix());
+    LadderCableTrans = new TGeoTranslation();
+    Double_t* LadderCableTransVector = LocalLadderCableHMatrix[i]->GetTranslation();
+    LadderCableTrans->SetTranslation(LadderCableTransVector[0],
+                                                                        LadderCableTransVector[1]
+                                       +                (i==0 ? BeamAxisTrans[0] : 0.)
+                                       *                                fgkCarbonFiberJunctionWidth,
+                                                                        LadderCableTransVector[2]);     
+       LadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*LadderCableTrans,
+                                                                                                  *LadderCableRot);
+       } 
+       LadderCableCombiTransMatrix[2] = 
+                                       AddTranslationToCombiTrans(LadderCableCombiTransMatrix[1],0.,
+                                       BeamAxisTrans[1]*fgkCarbonFiberJunctionWidth,0.);
+       LadderCableCombiTransMatrix[3] = 
+                                       AddTranslationToCombiTrans(LadderCableCombiTransMatrix[0],0.,
+                                       BeamAxisTrans[2]*fgkCarbonFiberJunctionWidth,0.);
+ }
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length, 
+                                                       Double_t height,Double_t width,Double_t* thickness){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  const Int_t ShapesNumber = 2;
+  Double_t Width[2] = {width,width};
+  TVector3** VertexPosition[ShapesNumber];
+  for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] = 
+                                                                                                       new TVector3*[VertexNumber];
+  //First Shape Vertex Positioning
+  VertexPosition[0][0] = new TVector3();
+  VertexPosition[0][1] = new TVector3(height);
+  VertexPosition[0][2] = new TVector3(thickness[0]);
+  VertexPosition[0][3] = new TVector3(*VertexPosition[0][1]);
+  //Second Shape Vertex Positioning
+  VertexPosition[1][0] = new TVector3(*VertexPosition[0][0]);
+  VertexPosition[1][1] = new TVector3(length);
+  VertexPosition[1][2] = new TVector3(thickness[1]);
+  VertexPosition[1][3] = new TVector3(VertexPosition[1][1]->X());
+  char* SSDSensorSupportShapeName[ShapesNumber] = 
+                                                       {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
+  TGeoArb8* SSDSensorSupportShape[ShapesNumber];
+  for(Int_t i = 0; i< ShapesNumber; i++) SSDSensorSupportShape[i] = 
+                                          GetArbShape(VertexPosition[i],Width,i==0 ? 
+                                                                                                        thickness[1]: thickness[0],
+                                                                                                 SSDSensorSupportShapeName[i]);
+  /////////////////////////////////////
+  //Setting Translations and Rotations: 
+  /////////////////////////////////////
+  TGeoRotation* SSDSensorSupportShapeRot[2];
+  SSDSensorSupportShapeRot[0] = 
+                                        new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
+  SSDSensorSupportShapeRot[1] = 
+                                        new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
+  TGeoTranslation* SSDSensorSupportShapeTrans = 
+                                        new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
+                                                                                                                         0.5*thickness[0]);
+  TGeoCombiTrans* SSDSensorSupportCombiTrans = 
+         new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
+                                                 new TGeoRotation((*SSDSensorSupportShapeRot[1])
+                                               *                  (*SSDSensorSupportShapeRot[0])));
+  TGeoVolume* SSDSensorSupportCompVolume = 
+                                                 new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
+  SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
+                                                       SSDSensorSupportShape[0],fgkSSDSensorSupportMedium),1,
+                                                       SSDSensorSupportShapeTrans);
+  SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
+                                                       SSDSensorSupportShape[1],fgkSSDSensorSupportMedium),1,
+                                                       SSDSensorSupportCombiTrans);
+  return SSDSensorSupportCompVolume;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* SSDSensorSupport;
+  Double_t SideSupportThickness[2] = {fgkSSDSensorSideSupportThickness[0],
+                                                                                  fgkSSDSensorSideSupportThickness[1]};
+  VolumeKind == 0 ? SSDSensorSupport = GetSSDSensorSupportShape(
+                                                               fgkSSDSensorSideSupportLength,
+                                                               fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
+                                                               fgkSSDSensorSideSupportWidth,
+                                                               SideSupportThickness) :
+    SSDSensorSupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
+                                                       fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
+                                                           fgkSSDSensorCenterSupportWidth,
+                                                           SideSupportThickness);
+  return SSDSensorSupport;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* SSDSensorSupportAssembly = 
+                                                        new TGeoVolumeAssembly("SSDSensorSupportAssembly");
+  const Int_t VolumeNumber = 2;
+  TGeoVolume* SSDSensorSupport[VolumeNumber];
+  for(Int_t i=0; i<VolumeNumber; i++) SSDSensorSupport[i] = 
+                                                                                                               GetSSDSensorSupport(i,n);
+  SetSSDSensorSupportCombiTransMatrix();
+  for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++) 
+       SSDSensorSupportAssembly->AddNode((i<2 ? SSDSensorSupport[0]:
+                                                                                        SSDSensorSupport[1]),
+                                                                                i+1,SSDSensorSupportCombiTransMatrix[i]);
+  return SSDSensorSupportAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* SSDModuleVolume[fgkSSDModuleCombiTransNumber-1];
+  SSDModuleVolume[0] = GetSSDStiffenerAssembly();
+  SSDModuleVolume[1] = GetSSDChipAssembly();
+  SSDModuleVolume[2] = GetSSDSensor();
+  SSDModuleVolume[3] = GetSSDFlexAssembly();
+  SSDModuleVolume[4] = GetSSDCoolingBlockAssembly();
+  SSDModuleVolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
+  SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
+  TGeoCombiTrans* SSDModuleGlobalCombiTrans = 
+                                                                  new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
+                                                                          fgkSSDModuleStiffenerPosition[0],
+                                                                          fgkSSDModuleStiffenerPosition[1],0.,NULL);
+  TGeoHMatrix* SSDModuleHMatrix[fgkSSDModuleCombiTransNumber];
+  TGeoVolume* SSDModule = new TGeoVolumeAssembly("SSDModule");
+  for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){ 
+       SSDModuleHMatrix[i] = new TGeoHMatrix((*SSDModuleGlobalCombiTrans)
+                                               *                                 (*SSDModuleCombiTransMatrix[i]));
+       SSDModule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? SSDModuleVolume[3] : 
+                                                 SSDModuleVolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
+                                                 SSDModuleHMatrix[i]);
+  }
+  return SSDModule;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
+////////////////////////////////////////////////////////////////////////////////
+  Double_t fgkSSDSensorSensitiveLength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
+  Double_t fgkSSDSensorSensitiveWidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
+  TGeoBBox* SSDSensorSensitiveShape = new TGeoBBox("SSDSensorSensitiveShape",
+                                                0.5*fgkSSDSensorSensitiveLength,
+                                                0.5*fgkSSDSensorSensitiveWidth,
+                                                0.5*fgkSSDSensorHeight);
+  TGeoVolume* SSDSensorSensitive = 
+      new TGeoVolume(fgkSSDSensitiveVolName,SSDSensorSensitiveShape,fgkSSDSensorMedium);
+  SSDSensorSensitive->SetLineColor(fColorSilicon);
+  TGeoBBox* SSDSensorInsensitiveShape[2];
+  SSDSensorInsensitiveShape[0] = new TGeoBBox("SSDSensorInSensitiveShape1",
+                                                0.5*fgkSSDSensorLength,
+                                                0.5*fgkSSDSensorInsensitiveWidth,
+                                                0.5*fgkSSDSensorHeight);
+  SSDSensorInsensitiveShape[1] = new TGeoBBox("SSDSensorInSensitiveShape2",
+                                                0.5*fgkSSDSensorInsensitiveWidth,
+                                                0.5*fgkSSDSensorSensitiveWidth,
+                                                0.5*fgkSSDSensorHeight);
+  const char* SSDSensorInsensitiveName[2] = {"SSDSensorInsensitive1",
+                                             "SSDSensorInsensitive2"};
+  TGeoVolume* SSDSensorInsensitive[2];
+  for(Int_t i=0; i<2; i++){ SSDSensorInsensitive[i] = 
+      new TGeoVolume(SSDSensorInsensitiveName[i],SSDSensorInsensitiveShape[i],
+                     fgkSSDSensorMedium);
+      SSDSensorInsensitive[i]->SetLineColor(fColorCarbonFiber);
+  }
+  TGeoVolume* SSDSensorInsensitiveVol = 
+                              new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
+  for(Int_t i=0; i<4; i++) 
+            SSDSensorInsensitiveVol->AddNode(i%2==0 ? SSDSensorInsensitive[0]:
+            SSDSensorInsensitive[1],i<2?1:2,
+                  new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
+      *     (SSDSensorSensitiveShape->GetDX()+SSDSensorInsensitiveShape[1]->GetDX()),
+                        0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
+      *     (SSDSensorSensitiveShape->GetDY()+SSDSensorInsensitiveShape[0]->GetDY()),0.));            
+  TGeoVolume* SSDSensor = new TGeoVolumeAssembly("SSDSensor");
+  SSDSensor->AddNode(SSDSensorSensitive,1),SSDSensor->AddNode(SSDSensorInsensitiveVol,1);
+  return SSDSensor;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t SSDChipRowNumber = 2;
+  TGeoBBox* SSDChipCompShape[2];
+  SSDChipCompShape[0] =  new TGeoBBox("SSDChipCompShape",
+                                                                               0.5*fgkSSDChipLength,
+                                                                               0.5*fgkSSDChipWidth,
+                                                                               0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
+  SSDChipCompShape[1] =  new TGeoBBox("SSDChipGlueCompShape",
+                                                                               0.5*fgkSSDChipLength,
+                                                                               0.5*fgkSSDChipWidth,
+                                                                               0.5*fgkSSDChipGlueHeight);
+  TGeoVolume* SSDChipComp[2];
+  SSDChipComp[0] = new TGeoVolume("SSDChipComp",SSDChipCompShape[0],fgkSSDChipMedium);
+  SSDChipComp[1] = new TGeoVolume("SSDChipGlueComp",SSDChipCompShape[1],
+                                                                 fgkSSDChipGlueMedium);
+  SSDChipComp[0]->SetLineColor(fColorSilicon);  
+  SSDChipComp[1]->SetLineColor(fColorEpoxy);
+  TGeoTranslation* SSDChipCompTrans[2];
+  SSDChipCompTrans[0] = new TGeoTranslation(0.,0.,-SSDChipCompShape[1]->GetDZ());
+  SSDChipCompTrans[1] = new TGeoTranslation(0.,0.,SSDChipCompShape[0]->GetDZ());
+  TGeoVolume* SSDChip = new TGeoVolumeAssembly("SSDChip");  
+  for(Int_t i=0; i<2; i++) SSDChip->AddNode(SSDChipComp[i],1,SSDChipCompTrans[i]);
+  Double_t SSDChipSeparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
+                                                 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+                                  -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
+                                  -  0.5*fgkSSDChipWidth)};
+  TGeoVolume* SSDChipAssembly = new TGeoVolumeAssembly("SSDChipAssembly"); 
+  for(Int_t i=0; i<SSDChipRowNumber; i++)
+    for(Int_t j=0; j<fgkSSDChipNumber; j++) 
+               SSDChipAssembly->AddNode(SSDChip,fgkSSDChipNumber*i+j+1,
+               new TGeoTranslation(j*SSDChipSeparation[0],i*SSDChipSeparation[1],0.));
+  return SSDChipAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t SSDStiffenerNumber = 2;
+  Double_t SSDStiffenerSeparation = fgkSSDSensorLength
+                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
+                                                                 -    fgkSSDStiffenerWidth;
+  TGeoVolume* SSDStiffener = new TGeoVolumeAssembly("SSDStiffener");
+////////////////////////////
+// Stiffener Volumes
+///////////////////////////
+  const Int_t StiffenerBoxNumber = 6;
+  TGeoBBox* SSDStiffenerBoxShapes[StiffenerBoxNumber];
+  SSDStiffenerBoxShapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
+                                                                                 0.5* fgkSSDStiffenerLength,
+                                                                                 0.5* fgkSSDStiffenerWidth,
+                                                                                 0.5*(fgkSSDStiffenerHeight
+                                                  -                   fgkSSDConnectorHeight));
+  SSDStiffenerBoxShapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
+                                                                                 0.5*(fgkSSDConnectorPosition[0]
+                                                  -              2.0* fgkSSDConnectorLength
+                                                  -                               fgkSSDConnectorSeparation),
+                                                                                 0.5* fgkSSDStiffenerWidth,
+                                                                                 0.5* fgkSSDConnectorHeight);
+  SSDStiffenerBoxShapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
+                                                                                 0.5*(fgkSSDConnectorSeparation
+                                                  +              2.*  fgkSSDConnectorLength),
+                                                                                 0.5* fgkSSDConnectorPosition[1],
+                                                                                 0.5* fgkSSDConnectorHeight);
+  SSDStiffenerBoxShapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
+                                                                                       SSDStiffenerBoxShapes[2]->GetDX(),
+                                                                                 0.5*(fgkSSDStiffenerWidth
+                                                  -                   fgkSSDConnectorPosition[1]
+                                                  -                   fgkSSDConnectorWidth),
+                                                                                 0.5* fgkSSDConnectorHeight);
+   SSDStiffenerBoxShapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
+                                                                                 0.5* fgkSSDConnectorSeparation,
+                                                                                 0.5* fgkSSDConnectorWidth,
+                                                                                 0.5* fgkSSDConnectorHeight);
+   SSDStiffenerBoxShapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
+                                                                                 0.5*(fgkSSDStiffenerLength
+                                                        -                                 fgkSSDConnectorPosition[0]),
+                                                                                 0.5* fgkSSDStiffenerWidth,
+                                                                                 0.5* fgkSSDConnectorHeight);
+  TGeoVolume* SSDStiffenerBox[StiffenerBoxNumber];
+  char SSDStiffenerBoxName[30];
+  for(Int_t i=0; i<StiffenerBoxNumber; i++){ 
+       sprintf(SSDStiffenerBoxName,"SSDStiffenerBox%i",i+1);
+    SSDStiffenerBox[i] = new TGeoVolume(SSDStiffenerBoxName,SSDStiffenerBoxShapes[i],
+                                                                         fgkSSDStiffenerMedium);
+       SSDStiffenerBox[i]->SetLineColor(fColorStiffener);
+  }
+////////////////////////////
+// Connector 
+///////////////////////////
+  TGeoBBox* SSDConnectorShape =  new TGeoBBox("SSDConnectorShape",
+                                                                                        0.5*fgkSSDConnectorLength,
+                                                                                        0.5*fgkSSDConnectorWidth,
+                                                                                        0.5*fgkSSDConnectorHeight);
+  TGeoVolume* SSDConnector    = new TGeoVolume("SSDConnector",SSDConnectorShape,
+                                                                                               fgkSSDStiffenerConnectorMedium); 
+  SSDConnector->SetLineColor(fColorAl);
+  const Int_t SSDConnectorNumber = 2;
+  TGeoTranslation* SSDConnectorTrans[SSDConnectorNumber];
+  SSDConnectorTrans[0] = new TGeoTranslation("SSDConnectorTrans1",
+        -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
+               -  fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
+                  SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
+               -  SSDConnectorShape->GetDY(),
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());       
+  SSDConnectorTrans[1] = new TGeoTranslation("SSDConnectorTrans2",
+        -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
+        -  0.5*fgkSSDConnectorLength,
+           SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
+               -  SSDConnectorShape->GetDY(),
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
+  for(Int_t i=0; i<SSDConnectorNumber; i++)
+                       SSDStiffener->AddNode(SSDConnector,i+1,SSDConnectorTrans[i]);   
+//////////////////////////////////////
+// TGeoTranslation for Stiffener Boxes
+//////////////////////////////////////
+  TGeoTranslation* SSDStiffenerBoxTrans[StiffenerBoxNumber];
+  SSDStiffenerBoxTrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
+  SSDStiffenerBoxTrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
+                - (SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[1]->GetDX()),
+                   0.,
+                       SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[1]->GetDZ());
+  SSDStiffenerBoxTrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
+         - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[2]->GetDX()
+                + fgkSSDConnectorPosition[0],
+                  SSDStiffenerBoxShapes[0]->GetDY()-SSDStiffenerBoxShapes[2]->GetDY(),
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[2]->GetDZ());
+  SSDStiffenerBoxTrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
+         - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[3]->GetDX()
+                + fgkSSDConnectorPosition[0],
+                - SSDStiffenerBoxShapes[0]->GetDY()+SSDStiffenerBoxShapes[3]->GetDY(),
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[3]->GetDZ());
+  SSDStiffenerBoxTrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
+                - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
+                - 0.5*fgkSSDConnectorSeparation-2.*SSDConnectorShape->GetDX(),
+                  SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
+                - SSDConnectorShape->GetDY(),
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
+  SSDStiffenerBoxTrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
+         - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
+                + SSDStiffenerBoxShapes[5]->GetDX(),
+                  0.,
+                  SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[5]->GetDZ());
+  for(Int_t i=0; i<StiffenerBoxNumber; i++) 
+               SSDStiffener->AddNode(SSDStiffenerBox[i],1,SSDStiffenerBoxTrans[i]);    
+  TGeoCombiTrans* SSDStiffenerCombiTrans[SSDStiffenerNumber];
+  char SSDStiffenerCombiTransName[30];
+    for(Int_t i=0; i<SSDStiffenerNumber; i++){ 
+       sprintf(SSDStiffenerCombiTransName,"SSDStiffenerCombiTrans%i",i+1);
+    SSDStiffenerCombiTrans[i] = new TGeoCombiTrans(SSDStiffenerCombiTransName,
+                       0.,i*SSDStiffenerSeparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
+  }
+////////////////////////////
+// Capacitor 0603-2200 nF
+///////////////////////////
+  const Int_t Capacitor0603Number = 5;
+  TGeoBBox* Capacitor0603Shape =  new TGeoBBox("Capacitor0603Shape",
+                                                                                        0.5*fgkSSDCapacitor0603Length,
+                                                                                        0.5*fgkSSDCapacitor0603Width,
+                                                                                        0.5*fgkSSDCapacitor0603Height);
+  TGeoVolume* Capacitor0603 = new TGeoVolume("Capacitor0603",Capacitor0603Shape,
+                                             fgkSSDStiffener0603CapacitorMedium); 
+  Capacitor0603->SetLineColor(fColorAl);
+////////////////////////////
+// Capacitor 1812-330 nF
+///////////////////////////
+  TGeoBBox* Capacitor1812Shape =  new TGeoBBox("Capacitor1812Shape",
+                                                                                        0.5*fgkSSDCapacitor1812Length,
+                                                                                        0.5*fgkSSDCapacitor1812Width,
+                                                                                        0.5*fgkSSDCapacitor1812Height);
+  TGeoVolume* Capacitor1812 = new TGeoVolume("Capacitor1812",Capacitor1812Shape,
+                                             fgkSSDStiffener1812CapacitorMedium); 
+  Capacitor1812->SetLineColor(fColorAl);
+  TGeoTranslation* Capacitor1812Trans = new TGeoTranslation("Capacitor1812Trans",
+                         0.,
+                         0.5*fgkSSDStiffenerWidth+SSDStiffenerSeparation
+              -  Capacitor1812Shape->GetDY()-fgkSSDConnectorPosition[1],
+                         SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
+                  +  0.5*fgkSSDCapacitor1812Height);
+////////////////////////////
+//Hybrid Wire
+////////////////////////////
+  Double_t WireX = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
+                                - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
+                                - fgkSSDConnectorSeparation;
+  Double_t WireY = SSDStiffenerSeparation+fgkSSDStiffenerWidth
+                                - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
+  Double_t SSDWireRadius = TMath::Sqrt(TMath::Power(WireX,2.)
+                                        + TMath::Power(WireY,2));
+  Double_t WireAngle = TMath::ATan(WireX/WireY);
+  TGeoTube *HybridWireShape = new TGeoTube("HybridWireShape", 0., 
+                                               fgkSSDWireRadius, 0.5*SSDWireRadius);
+  TGeoVolume* HybridWire = new TGeoVolume("HybridWire",HybridWireShape,
+                                             fgkSSDStiffenerHybridWireMedium); 
+  HybridWire->SetLineColor(fColorPhynox);
+  TGeoCombiTrans* HybridWireCombiTrans[2];
+  HybridWireCombiTrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
+                   0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
+                                + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
+                   0.5*SSDWireRadius-0.5*fgkSSDStiffenerWidth
+                                + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
+                                  SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
+                                + fgkSSDWireRadius,
+                   new TGeoRotation("HybridWireRot1",0.,90.,0.));
+  HybridWireCombiTrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
+                                  0.,
+                                - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
+                                  0.,  
+                   new TGeoRotation("HybridWireRot2",
+                                -                  WireAngle*TMath::RadToDeg(),0.,0.));
+  TGeoHMatrix* HybridWireMatrix = new TGeoHMatrix();
+  HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[0]);
+  HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[1]);
+////////////////////////////
+// Stiffener Assembly
+///////////////////////////
+  TGeoVolume* SSDStiffenerAssembly = 
+                                                               new TGeoVolumeAssembly("SSDStiffenerAssembly");
+  SSDStiffenerAssembly->AddNode(HybridWire,1,HybridWireMatrix);
+  for(Int_t i=0; i<SSDStiffenerNumber; i++) {
+       SSDStiffenerAssembly->AddNode(SSDStiffener,i+1,SSDStiffenerCombiTrans[i]);
+       for(Int_t j=1; j<Capacitor0603Number+1; j++){
+    SSDStiffenerAssembly->AddNode(Capacitor0603,Capacitor0603Number*i+j,new TGeoTranslation("",(j-3.
+       )/6*fgkSSDStiffenerLength,
+                                       i*SSDStiffenerSeparation+
+                                       0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
+                                       +(i==0? -1:+1)*fgkSSDCapacitor0603Width),
+                                       -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
+       }
+       if(i==1) SSDStiffenerAssembly->AddNode(Capacitor1812,1,Capacitor1812Trans);
+}
+  return SSDStiffenerAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, 
+                                                                                                                                       char* side){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t SSDChipCablesLayNumber = 2;
+  Int_t SSDChipCablesColor[2] = {fColorAl,fColorPolyhamide};
+  Double_t SSDChipCablesRadius[2];
+  SSDChipCablesRadius[0] = 0.25*(SSDChipCablesHeigth
+                                                -  fgkSSDChipCablesHeight[0]
+                                                -  fgkSSDChipCablesHeight[1]);
+  SSDChipCablesRadius[1] = SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0];
+  Double_t SSDChipCablesPieceLength = 0.5*(fgkSSDChipCablesWidth[0]
+                                                                   - 2.*TMath::Pi()*SSDChipCablesRadius[0]
+                                                                       - SSDChipCablesRadius[0]
+                                                                       - fgkSSDChipCablesWidth[1]
+                                                                       - fgkSSDChipCablesWidth[2]
+                                                                       - (side=="Right" ? 0 : 
+                                                                         fgkSSDModuleStiffenerPosition[1]
+                                                                       + TMath::Pi()*(0.5*fgkSSDSensorHeight
+                                                                       + fgkSSDChipCablesHeight[0]
+                                                                       + fgkSSDChipCablesHeight[1])));
+  //////////////////////////
+  //Box and Tube Seg Shapes
+  //////////////////////////
+  char* SSDChipCablesBoxShapeName[2*SSDChipCablesLayNumber] = 
+                                         {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
+                                          "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
+  char* SSDChipCablesTubeSegShapeName[2*SSDChipCablesLayNumber] = 
+                         {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
+                          "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
+  TGeoBBox** SSDChipCablesBoxShape[SSDChipCablesLayNumber];
+  TGeoTubeSeg** SSDChipCablesTubeSegShape[SSDChipCablesLayNumber];
+  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
+    SSDChipCablesBoxShape[i]        = new TGeoBBox*[2];
+    SSDChipCablesTubeSegShape[i]    = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
+    SSDChipCablesBoxShape[i][0]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i],
+                                                                                                  0.5*SSDChipCablesPieceLength,
+                                                                                                  0.5*fgkSSDChipCablesLength[1],
+                                                                                                  0.5*fgkSSDChipCablesHeight[i]);
+    SSDChipCablesBoxShape[i][1]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i+1],
+                                                  0.5*(SSDChipCablesPieceLength+SSDChipCablesRadius[0]
+                                        + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),            
+                                   0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
+    SSDChipCablesTubeSegShape[i][0] = 
+                                          new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],                                          
+                                                  SSDChipCablesRadius[1]-i*fgkSSDChipCablesHeight[1],
+                                                  SSDChipCablesRadius[i],0.5*fgkSSDChipCablesLength[1],
+                                                  0.,180.);
+    SSDChipCablesTubeSegShape[i][1] = 
+                                          new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i+1],
+                                                SSDChipCablesRadius[0]+i*fgkSSDChipCablesHeight[0],
+                                                        SSDChipCablesRadius[0]+fgkSSDChipCablesHeight[0]
+                                        +               i*fgkSSDChipCablesHeight[1],
+                                                        0.5*fgkSSDChipCablesLength[1],0.,180.);
+    if(side!="Right") SSDChipCablesTubeSegShape[i][2] = 
+                                        new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
+                                                0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
+                                                0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
+                                        +   fgkSSDChipCablesHeight[1],
+                                                0.5*fgkSSDChipCablesLength[1],0.,180.);
+  }
+  //////////////////////////
+  //Box under Chip
+  //////////////////////////
+  char SSDUnderChipCablesBoxShapeName[30];
+  char SSDUnderChipCablesBoxName[30];  
+  char SSDUnderChipCablesBoxTransName[30];     
+  TGeoBBox* SSDUnderChipCablesBoxShape[SSDChipCablesLayNumber];
+  TGeoVolume* SSDUnderChipCablesBox[SSDChipCablesLayNumber]; 
+  TGeoTranslation* SSDUnderChipCablesBoxTrans[SSDChipCablesLayNumber];
+  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){ 
+               sprintf(SSDUnderChipCablesBoxShapeName,"SSDUnderChipCablesBoxShape%i",i+1);
+               sprintf(SSDUnderChipCablesBoxName,"SSDUnderChipCablesBox%i",i+1);
+               sprintf(SSDUnderChipCablesBoxTransName,"SSDUnderChipCablesBoxTrans%i",i+1);
+               SSDUnderChipCablesBoxShape[i] = 
+                                                                  new TGeoBBox(SSDUnderChipCablesBoxShapeName,
+                                                                  0.5*fgkSSDChipWidth,
+                                                                  0.5*fgkSSDChipCablesLength[1],
+                                                                  0.5*fgkSSDChipCablesHeight[i]);
+               SSDUnderChipCablesBox[i] = new TGeoVolume(SSDUnderChipCablesBoxName,
+                                                                       SSDUnderChipCablesBoxShape[i],
+                                                                       (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));               
+        SSDUnderChipCablesBox[i]->SetLineColor(SSDChipCablesColor[i]);
+               SSDUnderChipCablesBoxTrans[i] = 
+                                               new TGeoTranslation(SSDUnderChipCablesBoxTransName,
+                                               (side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
+                                               0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
+                                               +0.5*fgkSSDChipCablesLength[1],
+                                               (i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
+  }
+  //////////////////
+  //Trapezoid Shapes
+  //////////////////
+  const Int_t SSDChipCablesVertexNumber = 2;
+  const Int_t SSDChipCablesTrapezoidNumber = 2;
+  TVector3** SSDChipCablesTrapezoidVertex[SSDChipCablesVertexNumber];
+  for(Int_t i = 0; i< SSDChipCablesTrapezoidNumber; i++) 
+        SSDChipCablesTrapezoidVertex[i] = new TVector3*[SSDChipCablesVertexNumber];
+  //First Shape Vertex Positioning
+  SSDChipCablesTrapezoidVertex[0][0] = new TVector3();
+  SSDChipCablesTrapezoidVertex[0][1] = 
+               new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
+  //Second Shape Vertex Positioning
+  SSDChipCablesTrapezoidVertex[1][0] = 
+                                                         new TVector3(*SSDChipCablesTrapezoidVertex[0][0]);
+  SSDChipCablesTrapezoidVertex[1][1] = 
+                                                         new TVector3(*SSDChipCablesTrapezoidVertex[0][1]);
+  //Setting the names of shapes and volumes
+  char* SSDChipCablesTrapezoidBoxShapeName[SSDChipCablesTrapezoidNumber] = 
+                 {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
+  char* SSDChipCablesTrapezoidShapeName[SSDChipCablesTrapezoidNumber] = 
+                 {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
+  char* SSDChipCablesTrapezoidBoxName[SSDChipCablesTrapezoidNumber] = 
+                 {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
+  char* SSDChipCablesTrapezoidName[SSDChipCablesTrapezoidNumber] = 
+                 {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
+  char* SSDChipCablesTrapezoidAssemblyName[SSDChipCablesTrapezoidNumber] = 
+                 {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
+  //Setting the Shapes
+  TGeoBBox* SSDChipCablesTrapezoidBoxShape[SSDChipCablesTrapezoidNumber]; 
+  TGeoArb8* SSDChipCablesTrapezoidShape[SSDChipCablesTrapezoidNumber];
+  //Setting the Volumes
+  TGeoVolume* SSDChipCablesTrapezoidBox[SSDChipCablesTrapezoidNumber];
+  TGeoVolume* SSDChipCablesTrapezoid[SSDChipCablesTrapezoidNumber];
+  TGeoVolume* SSDChipCablesTrapezoidAssembly[SSDChipCablesTrapezoidNumber]; 
+  Double_t SSDChipCablesTrapezoidWidth[SSDChipCablesVertexNumber] = 
+   {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
+  for(Int_t i=0; i<SSDChipCablesTrapezoidNumber; i++){
+    SSDChipCablesTrapezoidBoxShape[i] = 
+                                       new TGeoBBox(SSDChipCablesTrapezoidBoxShapeName[i],
+                                               0.5*fgkSSDChipCablesLength[1],
+                                           0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
+                                               0.5*fgkSSDChipCablesHeight[i]);
+    SSDChipCablesTrapezoidShape[i] = 
+                                                         GetTrapezoidShape(SSDChipCablesTrapezoidVertex[i],
+                                                         SSDChipCablesTrapezoidWidth,
+                                                         fgkSSDChipCablesHeight[i],
+                                                         SSDChipCablesTrapezoidShapeName[i]);
+    SSDChipCablesTrapezoidBox[i] = 
+                                               new TGeoVolume(SSDChipCablesTrapezoidBoxName[i],
+                                                                          SSDChipCablesTrapezoidBoxShape[i],
+                                                                          (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
+    SSDChipCablesTrapezoid[i] = new TGeoVolume(SSDChipCablesTrapezoidName[i],
+                                                                                          SSDChipCablesTrapezoidShape[i],
+                                                                                          (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
+    SSDChipCablesTrapezoidBox[i]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesTrapezoid[i]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesTrapezoidAssembly[i] = 
+                               new TGeoVolumeAssembly(SSDChipCablesTrapezoidAssemblyName[i]);
+    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoidBox[i],1,
+                               new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
+                                  0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
+    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],0,
+                       new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
+    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],1,
+                       new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
+  }
+  /////////////////////////////
+  //Box and Tube Seg CombiTrans
+  /////////////////////////////
+  TGeoTranslation* SSDChipCablesBoxTrans[2*SSDChipCablesLayNumber];
+  SSDChipCablesBoxTrans[0] = 
+                                       new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
+  SSDChipCablesBoxTrans[1] = 
+                                       new TGeoTranslation("SSDChipCablesLay1Box2Trans",
+                                                                                SSDChipCablesBoxShape[0][1]->GetDX()
+                                                  -             0.5*SSDChipCablesPieceLength,
+                       0.0,
+                                                  -             2.*SSDChipCablesRadius[0]
+                                                  -             fgkSSDChipCablesHeight[0]);
+  SSDChipCablesBoxTrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
+                                                                                0.0,
+                                                                                0.0,
+                                                                                0.5*(fgkSSDChipCablesHeight[0]
+                                                  +                     fgkSSDChipCablesHeight[1]));
+  SSDChipCablesBoxTrans[3] = 
+                                                        new TGeoTranslation("SSDChipCablesLay2Box2Trans",
+                                                                                SSDChipCablesBoxShape[1][1]->GetDX()
+                                                  -                     0.5*SSDChipCablesPieceLength,
+                                                                                0.0,
+                                                  -                     2.*SSDChipCablesRadius[0]
+                                                  -                     0.5*fgkSSDChipCablesHeight[1]
+                                                  -                     1.5*fgkSSDChipCablesHeight[0]);
+  TGeoRotation* SSDChipCablesRot[3];
+  SSDChipCablesRot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
+  SSDChipCablesRot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
+  SSDChipCablesRot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
+  TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
+                                                                                                         (side=="Right" ? 0 : 1))];
+  SSDChipCablesTubeSegCombiTrans[0] = 
+                               new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
+                               0.5*SSDChipCablesPieceLength,
+                               0.0,
+                               SSDChipCablesRadius[0]
+                       -   0.5*fgkSSDChipCablesHeight[0],
+                               new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
+  SSDChipCablesTubeSegCombiTrans[1] = 
+                               new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
+                       -   0.5*SSDChipCablesPieceLength,
+                               0.0,
+                       -   SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
+                               new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
+  SSDChipCablesTubeSegCombiTrans[2] = 
+  new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
+                               0.5*SSDChipCablesPieceLength,
+                               0.0,
+                               SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
+                               new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
+  SSDChipCablesTubeSegCombiTrans[3] = 
+                               new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
+                       -       0.5*SSDChipCablesPieceLength,
+                               0.0,
+                       -       SSDChipCablesRadius[0]+0.5*fgkSSDChipCablesHeight[0]
+                       -   fgkSSDChipCablesHeight[0],
+                               new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
+  SSDChipCablesTubeSegCombiTrans[4] = 
+                               new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
+                               0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
+                       +   fgkSSDModuleStiffenerPosition[1],
+                               0.0,
+                       -       2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
+                       -   (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
+                       +       fgkSSDChipCablesHeight[1]),
+                       new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
+  SSDChipCablesTubeSegCombiTrans[5] = 
+                       new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
+                               0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
+                       +       fgkSSDModuleStiffenerPosition[1],
+                               0.0,
+                       -       2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
+                       -       (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
+                       +       fgkSSDChipCablesHeight[1]),
+                       new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
+  TGeoCombiTrans* SSDChipCablesTrapezoidCombiTrans[SSDChipCablesLayNumber];
+  SSDChipCablesTrapezoidCombiTrans[0] = (side=="Right" ? 
+                       new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
+                               0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
+                       +       SSDChipCablesRadius[0],
+                       -       0.5*fgkSSDChipCablesLength[1],
+                       -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
+                       new TGeoRotation("",90.,0.,0.)) :
+                       new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
+                       -       2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
+                       +       0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
+                       +       SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
+                               0.5*fgkSSDChipCablesLength[1],
+                       -       2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
+                       -       2.*SSDChipCablesRadius[0]-fgkSSDSensorHeight,
+                       new TGeoRotation("",-90.,0.,0.)));
+  SSDChipCablesTrapezoidCombiTrans[1] = (side=="Right" ? 
+                       new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
+                               0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
+                       +       SSDChipCablesRadius[0],
+                       -       0.5*fgkSSDChipCablesLength[1],
+                       -       0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
+                       -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
+                               new TGeoRotation("",90.,0.,0.)) :
+                               new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
+                       -       2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
+                       +       0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
+                       +       SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
+                               0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
+                       +       fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
+                       -       fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0]
+                       -       fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));  
+  //////////////////////////
+  //Box and Tube Seg Volumes
+  //////////////////////////
+  char* SSDChipCablesBoxName[2*SSDChipCablesLayNumber] = 
+                                                        {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
+                                                         "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
+  char* SSDChipRightCablesTubeSegName[2*SSDChipCablesLayNumber] = 
+                         {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
+                          "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
+  char* SSDChipLeftCablesTubeSegName[2*SSDChipCablesLayNumber] = 
+                         {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
+                          "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
+  char* SSDChipCablesLayAssemblyName[SSDChipCablesLayNumber] = 
+                         {"SSDChipCablesLay1","SSDChipCablesLay2"};
+  TGeoVolume** SSDChipCablesBox[SSDChipCablesLayNumber];
+  TGeoVolume** SSDChipCablesTubeSeg[SSDChipCablesLayNumber];
+  TGeoVolume* SSDChipCablesLayAssembly[SSDChipCablesLayNumber];
+  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
+    TGeoMedium* SSDChipCablesLayMed = 
+            (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium);
+    SSDChipCablesBox[i] = new TGeoVolume*[2];
+    SSDChipCablesTubeSeg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
+    SSDChipCablesBox[i][0] = new TGeoVolume(SSDChipCablesBoxName[2*i],
+                                          SSDChipCablesBoxShape[i][0],SSDChipCablesLayMed);
+    SSDChipCablesBox[i][1] = new TGeoVolume(SSDChipCablesBoxName[2*i+1],
+                                          SSDChipCablesBoxShape[i][1],SSDChipCablesLayMed);
+    SSDChipCablesTubeSeg[i][0] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i],
+                                          SSDChipCablesTubeSegShape[i][0],SSDChipCablesLayMed);
+    SSDChipCablesTubeSeg[i][1] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i+1],
+                                          SSDChipCablesTubeSegShape[i][1],SSDChipCablesLayMed);
+    SSDChipCablesBox[i][0]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesBox[i][1]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesTubeSeg[i][0]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesTubeSeg[i][1]->SetLineColor(SSDChipCablesColor[i]);
+    SSDChipCablesLayAssembly[i] = new TGeoVolumeAssembly(SSDChipCablesLayAssemblyName[i]);
+    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][0],1,
+                                                                                SSDChipCablesBoxTrans[2*i]);
+    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][1],1,
+                                                                                SSDChipCablesBoxTrans[2*i+1]);
+    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][0],1,
+                                                                                SSDChipCablesTubeSegCombiTrans[2*i]);
+    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][1],1,
+                                                                                SSDChipCablesTubeSegCombiTrans[2*i+1]);
+    if(side!="Right"){
+      SSDChipCablesTubeSeg[i][2] = new TGeoVolume(SSDChipLeftCablesTubeSegName[2*i],
+                                                                                                 SSDChipCablesTubeSegShape[i][2],
+                                                                                                 SSDChipCablesLayMed);
+      SSDChipCablesTubeSeg[i][2]->SetLineColor(SSDChipCablesColor[i]);
+      SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][2],1,
+                                                                                  SSDChipCablesTubeSegCombiTrans[4+i]);
+    }
+    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTrapezoidAssembly[i],1,
+                                                                                SSDChipCablesTrapezoidCombiTrans[i]);
+  }
+  TGeoCombiTrans* SSDChipCablesCombiTrans[SSDChipCablesLayNumber];
+  SSDChipCablesCombiTrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
+                                          (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
+                                               0.5*fgkSSDChipCablesLength[0],
+                                       -       (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
+                                       -       0.5*fgkSSDChipCablesHeight[1]),
+                                               new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
+  SSDChipCablesCombiTrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
+                                               (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
+                                               0.5*fgkSSDChipCablesLength[0],
+                                       -       (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
+                                       -       0.5*fgkSSDChipCablesHeight[1]),
+                                               new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
+  TGeoVolume* SSDChipCablesAssembly = 
+                                               new TGeoVolumeAssembly("SSDChipCables");
+  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){ 
+               SSDChipCablesAssembly->AddNode(SSDChipCablesLayAssembly[i],1,
+                                                                                                       SSDChipCablesCombiTrans[i]);
+               SSDChipCablesAssembly->AddNode(SSDUnderChipCablesBox[i],1,SSDUnderChipCablesBoxTrans[i]);
+  }
+  return SSDChipCablesAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t ChipCablesNumber = 2;
+  Double_t ChipCablesTransVector = fgkSSDSensorLength
+                                                                - 2.*fgkSSDModuleStiffenerPosition[1]
+                                                                - 2.*(fgkSSDStiffenerWidth
+                                                                - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
+  char* SSDChipCablesName[ChipCablesNumber] = {"Right","Left"};
+  TGeoVolume* SSDChipCables[ChipCablesNumber];  
+  TGeoVolume* SSDChipCablesAssembly = 
+                                        new TGeoVolumeAssembly("SSDChipCablesAssembly");
+  for(Int_t i=0; i<ChipCablesNumber; i++) SSDChipCables[i] = 
+                                        GetSSDChipCables(SSDChipCablesHeigth,SSDChipCablesName[i]);
+  for(Int_t i=0; i<ChipCablesNumber; i++)
+    for(Int_t j=0; j<fgkSSDChipNumber; j++)
+      SSDChipCablesAssembly->AddNode(SSDChipCables[i],fgkSSDChipNumber*i+j+1,
+                       new TGeoTranslation(-(SSDChipCablesName[i]=="Left" ? 1. : 0.)
+               *       ChipCablesTransVector,(j-0.5)*fgkSSDChipCablesLength[0]
+               +       0.5*fgkSSDChipCablesLength[1],0.));
+  return SSDChipCablesAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t SSDFlexRadius, Double_t SSDFlexHeigth){
+////////////////////////////////////////////////////////////////////////////////  
+  const Int_t SSDFlexVolumeNumber = 3;
+  TGeoVolume* SSDFlexVolume[SSDFlexVolumeNumber];
+  ////////////////////////
+  // Setting Display Color
+  ////////////////////////
+  Int_t SSDFlexColor;
+  SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
+  TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
+                            fgkSSDKaptonFlexMedium);
+  ////////////////////////
+  // SSDFlexTrapezoidShape
+  ////////////////////////
+  const Int_t SSDFlexVertexNumber = 2;
+  Double_t SSDFlexWidth[SSDFlexVertexNumber] = {fgkSSDFlexWidth[1],
+                                                                                               fgkSSDFlexWidth[0]};
+  TVector3* SSDFlexVertex[SSDFlexVertexNumber];
+  SSDFlexVertex[0] = new TVector3();
+  SSDFlexVertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
+  TGeoArb8* SSDFlexTrapezoidShape = GetTrapezoidShape(SSDFlexVertex,
+                                                                                                         SSDFlexWidth,SSDFlexHeigth,
+                                                                                                         "SSDFlexTrapezoidShape");
+  SSDFlexVolume[0] = new TGeoVolume("SSDFlexTrapezoid",SSDFlexTrapezoidShape,SSDFlexMed);
+  SSDFlexVolume[0]->SetLineColor(SSDFlexColor);
+  /////////////////////////
+  //SSDFlexTubeSeg Assembly
+  /////////////////////////
+  const Int_t SSDFlexTubeSegNumber = 2;
+  TGeoTubeSeg* SSDFlexTubeSegShape[SSDFlexTubeSegNumber];
+  Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
+                                                       /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
+  SSDFlexTubeSegShape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
+                                                  SSDFlexRadius,SSDFlexRadius+SSDFlexHeigth,
+                                                  0.5*fgkSSDFlexWidth[0],0.,180.);
+  SSDFlexTubeSegShape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
+                                                  SSDFlexRadiusMax-SSDFlexRadius-SSDFlexHeigth,
+                                                  SSDFlexRadiusMax-SSDFlexRadius,0.5*fgkSSDFlexWidth[0],
+                                                  0.,2.*fgkSSDFlexAngle);
+  TGeoRotation** SSDFlexTubSegRot[SSDFlexTubeSegNumber];
+  for(Int_t i = 0; i<SSDFlexTubeSegNumber; i++) 
+                                                                         SSDFlexTubSegRot[i] = new TGeoRotation*[2]; 
+  SSDFlexTubSegRot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90.,  0.);
+  SSDFlexTubSegRot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
+  SSDFlexTubSegRot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90.,  0.);
+  SSDFlexTubSegRot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
+  TGeoCombiTrans* SSDFlexTubeSegCombiTrans[SSDFlexTubeSegNumber];
+  SSDFlexTubeSegCombiTrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
+                                                               fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
+                                                               SSDFlexRadius+0.5*SSDFlexHeigth,
+                                                               new TGeoRotation((*SSDFlexTubSegRot[0][1])
+                                                       *       (*SSDFlexTubSegRot[0][0])));
+  SSDFlexTubeSegCombiTrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
+                                                               fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
+                                                               0.5*fgkSSDFlexWidth[0],
+                                                               SSDFlexRadiusMax+0.5*SSDFlexHeigth+SSDFlexRadius,
+                                                               new TGeoRotation((*SSDFlexTubSegRot[1][1])
+                                                       *       (*SSDFlexTubSegRot[1][0])));
+  SSDFlexVolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
+  TGeoVolume* SSDFlexTubeSeg[SSDFlexTubeSegNumber];
+  char SSDFlexTubeSegName[30];
+  for(Int_t i=0; i<SSDFlexTubeSegNumber; i++){ 
+               sprintf(SSDFlexTubeSegName,"SSDFlexTubeSeg%i",i+1);
+               SSDFlexTubeSeg[i] = new TGeoVolume(SSDFlexTubeSegName,SSDFlexTubeSegShape[i],
+                                     SSDFlexMed);
+               SSDFlexTubeSeg[i]->SetLineColor(SSDFlexColor);
+        SSDFlexVolume[1]->AddNode(SSDFlexTubeSeg[i],1,SSDFlexTubeSegCombiTrans[i]);
+  }
+  ///////////
+  //Box Shape 
+  ///////////
+  const Int_t SSDFlexBoxNumber = 7;
+  Double_t SSDFlexBoxLength[SSDFlexBoxNumber];
+  SSDFlexBoxLength[0] = 0.5*(fgkSSDChipNumber
+                                         *     fgkSSDChipLength+(fgkSSDChipNumber-1)
+                                         *     fgkSSDChipSeparationLength
+                                         - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
+                                         - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
+  SSDFlexBoxLength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
+  SSDFlexBoxLength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
+                                         -     fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);      
+  SSDFlexBoxLength[3] = fgkSSDFlexHoleWidth;   
+  SSDFlexBoxLength[4] = fgkSSDFlexLength[1]-SSDFlexBoxLength[0]
+                                         -     SSDFlexBoxLength[1];
+  SSDFlexBoxLength[5] = fgkSSDFlexLength[2];   
+  SSDFlexBoxLength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+                                         *     TMath::DegToRad()*SSDFlexRadiusMax
+                                         - fgkSSDFlexLength[2]-TMath::Pi()
+                                         *     fgkSSDStiffenerHeight-fgkSSDFlexLength[0];      
+  Double_t SSDFlexBoxWidth[SSDFlexBoxNumber];
+  SSDFlexBoxWidth[0] = fgkSSDFlexWidth[0];
+  SSDFlexBoxWidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
+  SSDFlexBoxWidth[2] = fgkSSDFlexHoleWidth;
+  SSDFlexBoxWidth[3] = SSDFlexBoxWidth[2]-fgkSSDFlexHoleLength;
+  SSDFlexBoxWidth[4] = fgkSSDFlexWidth[0];
+  SSDFlexBoxWidth[5] = fgkSSDFlexWidth[0];
+  SSDFlexBoxWidth[6] = fgkSSDFlexWidth[0];
+  TGeoBBox* SSDFlexBoxShape[SSDFlexBoxNumber+1];
+  for(Int_t i=0; i<SSDFlexBoxNumber+1; i++) SSDFlexBoxShape[i] = 
+                                               (i!= SSDFlexBoxNumber ? new TGeoBBox("SSDFlexBoxShape",
+                                                               0.5*SSDFlexBoxLength[i],
+                                                               0.5*SSDFlexBoxWidth[i],0.5*SSDFlexHeigth) : 
+                                                               SSDFlexBoxShape[2]);
+  //////////////////////////////
+  //SSDFlex Box Shape CombiTrans 
+  //////////////////////////////
+  TGeoCombiTrans* SSDFlexBoxCombiTrans[SSDFlexBoxNumber+1];
+  SSDFlexBoxCombiTrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
+                                                               SSDFlexVertex[1]->X()+0.5*SSDFlexBoxLength[0],
+                                                               0.5*fgkSSDFlexWidth[0],0.,0);
+  SSDFlexBoxCombiTrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
+                                                               SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
+                                                       +       0.5*SSDFlexBoxLength[1],
+                                                               fgkSSDFlexHoleWidth+0.5*SSDFlexBoxWidth[1],0.,0);
+  SSDFlexBoxCombiTrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
+                                                               SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
+                                                       +       fgkSSDFlexHoleLength+0.5*SSDFlexBoxLength[2],
+                                                               0.5*SSDFlexBoxWidth[2],0.,0);
+  SSDFlexBoxCombiTrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
+                                                               SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
+                                                       +       fgkSSDFlexHoleLength+SSDFlexBoxLength[2]
+                                                       +       0.5*fgkSSDFlexHoleWidth,
+                                                               fgkSSDFlexHoleLength+0.5*SSDFlexBoxWidth[3],0.,0);
+  SSDFlexBoxCombiTrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
+                                                               SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
+                                                       +       SSDFlexBoxLength[1]+0.5*SSDFlexBoxLength[4],
+                                                               0.5*fgkSSDFlexWidth[0],0.,0);
+  SSDFlexBoxCombiTrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
+                                                       -       0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
+                                                               0.5*fgkSSDFlexWidth[0],
+                                                               2.*SSDFlexRadius+SSDFlexHeigth,0);
+  SSDFlexBoxCombiTrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
+                                                       -       SSDFlexBoxShape[6]->GetDX()
+                                                       +       SSDFlexBoxShape[6]->GetDX()
+                                                       *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
+                                                       +       fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
+                                                       -       (SSDFlexRadiusMax-SSDFlexRadius-0.5*SSDFlexHeigth)
+                                                       *       TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
+                                                               0.5*fgkSSDFlexWidth[0],SSDFlexBoxShape[6]->GetDX()
+                                                               *TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
+                                                       +       SSDFlexHeigth+2.*SSDFlexRadius+(SSDFlexRadiusMax
+                                                       -       SSDFlexRadius-0.5*SSDFlexHeigth)
+                                                       *       TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
+                                                               new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
+  SSDFlexBoxCombiTrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
+                                                               SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
+                                                       +       fgkSSDFlexHoleLength+1.5*SSDFlexBoxLength[2]
+                                                       +       SSDFlexBoxLength[3],
+                                                               0.5*SSDFlexBoxWidth[2],0.,0);
+  ////////////////////////////
+  //SSDFlex Box Shape Assembly 
+  ////////////////////////////
+  SSDFlexVolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
+  TGeoVolume* SSDFlexBox[SSDFlexBoxNumber+1];
+  TGeoVolume* SSDEndFlex = GetSSDEndFlex(SSDFlexBoxLength[6],SSDFlexHeigth);
+  TGeoHMatrix* SSDEndFlexHMatrix = new TGeoHMatrix();
+  TGeoRotation* SSDEndFlexRot= new TGeoRotation("SSDEndFlexRot",180.,0.,0);
+  SSDEndFlexHMatrix->MultiplyLeft(SSDEndFlexRot);
+  SSDEndFlexHMatrix->MultiplyLeft(SSDFlexBoxCombiTrans[6]);
+  char SSDFlexBoxName[30];
+  for(Int_t i=0; i<SSDFlexBoxNumber+1; i++){
+       sprintf(SSDFlexBoxName,"SSDFlexBox%i",i!=SSDFlexBoxNumber?i+1:7);
+       if(i==6){SSDFlexVolume[2]->AddNode(SSDEndFlex,1,SSDEndFlexHMatrix);}
+       else{
+    SSDFlexBox[i] = new TGeoVolume(SSDFlexBoxName,SSDFlexBoxShape[i],
+                                   SSDFlexMed);
+       SSDFlexBox[i]->SetLineColor(SSDFlexColor);
+       SSDFlexVolume[2]->AddNode(SSDFlexBox[i],1,SSDFlexBoxCombiTrans[i]);}
+ }
+  //////////////////////
+  //SSDFlex Construction
+  //////////////////////
+  TGeoVolume* SSDFlex = new TGeoVolumeAssembly("SSDFlex");
+  for(Int_t i =0; i<SSDFlexVolumeNumber; i++) SSDFlex->AddNode(SSDFlexVolume[i],1);
+  return SSDFlex;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength, 
+                                                                                                               Double_t SSDFlexHeigth){
+  /////////////////////////////////////////
+  // Setting Display Color, Media and Index
+  /////////////////////////////////////////
+  Int_t SSDFlexColor;
+  SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
+  TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
+                            fgkSSDKaptonFlexMedium);
+  ////////////////////////
+  const Int_t SSDEndFlexBoxNumber = 5;
+  TGeoBBox* SSDEndFlexBBoxShape[SSDEndFlexBoxNumber];
+  SSDEndFlexBBoxShape[0] = new TGeoBBox("SSDFlexBoxShape1",
+                                                                  0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
+                                                                  0.5*SSDFlexHeigth);
+  SSDEndFlexBBoxShape[1] = new TGeoBBox("SSDFlexBoxShape2",
+                                   0.5*fgkSSDEndFlexCompLength[1],
+                                       0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
+                                       0.5*SSDFlexHeigth);
+  SSDEndFlexBBoxShape[2] = new TGeoBBox("SSDFlexBoxShape3",
+                                   0.5*fgkSSDEndFlexCompLength[2],
+                                       0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
+                                       0.5*SSDFlexHeigth);
+  SSDEndFlexBBoxShape[3] = new TGeoBBox("SSDFlexBoxShape4",
+                                   0.5*fgkSSDEndFlexCompLength[3],
+                                       0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
+                                       0.5*SSDFlexHeigth);
+  SSDEndFlexBBoxShape[4] = new TGeoBBox("SSDFlexBoxShape5",
+                                   0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
+                                       0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
+                                       0.5*SSDFlexHeigth);
+  TGeoVolume* SSDEndFlexBBox[SSDEndFlexBoxNumber];  
+  char SSDEndFlexBBoxName[30];
+  for(Int_t i=0; i<SSDEndFlexBoxNumber; i++){
+       sprintf(SSDEndFlexBBoxName,"SSDEndFlexBBox%i",i+1);
+       SSDEndFlexBBox[i] = new TGeoVolume(SSDEndFlexBBoxName,
+                     SSDEndFlexBBoxShape[i],
+                     SSDFlexMed);
+       SSDEndFlexBBox[i]->SetLineColor(SSDFlexColor);
+  }
+  TGeoVolume* SSDEndFlex = new TGeoVolumeAssembly("SSDEndFlex");
+  Double_t PartialSumLength = 0.;
+  for(Int_t i=0; i<SSDEndFlexBoxNumber+1; i++) PartialSumLength += fgkSSDEndFlexCompLength[i];
+  Double_t ReferenceLength = SSDEndFlexLength-PartialSumLength;
+  SSDEndFlex->AddNode(SSDEndFlexBBox[0],1);
+  SSDEndFlex->AddNode(SSDEndFlexBBox[1],1,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  0.5*fgkSSDEndFlexCompLength[1],
+                                          0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[1]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[1],2,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  0.5*fgkSSDEndFlexCompLength[1],
+                                       -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[1]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[2],1,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
+                                       +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[2]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[2],2,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
+                                       -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[2]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[3],1,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
+                                       +  0.5*fgkSSDEndFlexCompLength[3],
+                                       +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[3]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[3],2,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
+                                       +  0.5*fgkSSDEndFlexCompLength[3],
+                                       -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[3]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[4],1,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
+                                       +  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
+                                       +  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[4]->GetDY(),
+                                          0.));
+  SSDEndFlex->AddNode(SSDEndFlexBBox[4],2,new TGeoTranslation(
+                                       -  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
+                                       +  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
+                                       +  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
+                                       +  fgkSSDEndFlexCompLength[5]),
+                                       -  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[4]->GetDY(),
+                                          0.));
+  return SSDEndFlex;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* SSDFlexAssembly = new TGeoVolumeAssembly("SSDFlexAssembly");
+  const Int_t SSDFlexLayerNumber = 4;
+  Double_t SSDFlexHeight[SSDFlexLayerNumber];
+  Double_t SSDFlexRadius[SSDFlexLayerNumber];
+  TGeoTranslation* SSDFlexTrans[SSDFlexLayerNumber];
+  for(Int_t i=0; i<SSDFlexLayerNumber; i++){ 
+    SSDFlexHeight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
+    SSDFlexRadius[i] = (i==0 ? fgkSSDStiffenerHeight : SSDFlexRadius[i-1]
+                                        +                                         SSDFlexHeight[i-1]);
+    SSDFlexTrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(SSDFlexHeight[0]
+                                        +                                         SSDFlexHeight[1])); 
+    SSDFlexAssembly->AddNode(GetSSDFlex(SSDFlexRadius[i],SSDFlexHeight[i]),i+1,
+                                                                                  SSDFlexTrans[i]);   
+  }
+  return SSDFlexAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t SSDCoolingBlockTransNumber = 2;
+  Double_t SSDCoolingBlockTransVector[SSDCoolingBlockTransNumber] = 
+                                       {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
+                                        fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+                               -        fgkSSDCoolingBlockWidth};
+  TGeoVolume* SSDCoolingBlock = GetSSDCoolingBlock();
+  TGeoVolume* SSDCoolingBlockAssembly = 
+                                                         new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
+  for(Int_t i=0; i<SSDCoolingBlockTransNumber; i++)
+    for(Int_t j=0; j<SSDCoolingBlockTransNumber; j++) 
+               SSDCoolingBlockAssembly->AddNode(SSDCoolingBlock,
+                                                 SSDCoolingBlockTransNumber*i+j+1,
+                                                 new TGeoTranslation(i*SSDCoolingBlockTransVector[0],
+                                                 j*SSDCoolingBlockTransVector[1],0.));
+  return SSDCoolingBlockAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
+/////////////////////////////////////////////////////////////////////////////////
+  // Center Cooling Block Hole
+  ////////////////////////////
+  Double_t CoolingBlockHoleAngle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
+                                                       /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
+  Double_t CoolingBlockHoleWidth = fgkSSDCoolingBlockWidth;
+  /*TGeoTubeSeg* CoolingBlockHoleShape = */ new TGeoTubeSeg("CoolingBlockHoleShape",
+                                               0.,
+                                               fgkSSDCoolingBlockHoleRadius[0],
+                                               0.5*CoolingBlockHoleWidth,
+                                               180.-CoolingBlockHoleAngle,360.+CoolingBlockHoleAngle);
+  TVector3* CoolingBlockHoleVertex[3];
+  CoolingBlockHoleVertex[0] = new TVector3();
+  CoolingBlockHoleVertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
+                                       *       TMath::Cos((90.-CoolingBlockHoleAngle)*TMath::DegToRad()),
+                                               fgkSSDCoolingBlockHoleRadius[0]
+                                       *       TMath::Sin((90.-CoolingBlockHoleAngle)*TMath::DegToRad()));
+  CoolingBlockHoleVertex[2] = new TVector3(CoolingBlockHoleVertex[1]->X(),
+                                       -       CoolingBlockHoleVertex[1]->Y());
+  /* TGeoArb8* CoolingBlockTriangleHoleShape = */
+                                               GetTriangleShape(CoolingBlockHoleVertex,
+                                               CoolingBlockHoleWidth,"CoolingBlockTriangleHoleShape");
+  TGeoRotation* CoolingBlockHoleRot = 
+                                                         new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
+  CoolingBlockHoleRot->RegisterYourself();
+  /* TGeoCompositeShape* CoolingTubeHoleShape  = */ 
+                              new TGeoCompositeShape("CoolingTubeHoleShape",
+                                                         "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
+                                                         "CoolingBlockHoleShape");
+  ///////////////////////////
+  // Cooling Block Trapezoids
+  ///////////////////////////
+  const Int_t VertexNumber = 4;
+  const Int_t TrapezoidNumber = 2;
+  TVector3** CoolingBlockTrapezoidVertex[TrapezoidNumber];
+  for(Int_t i = 0; i<TrapezoidNumber; i++) CoolingBlockTrapezoidVertex[i] = 
+                                               new TVector3*[VertexNumber]; 
+  Double_t CoolingBlockComponentHeight    = fgkSSDCoolingBlockHeight[0]
+                                   -   fgkSSDCoolingBlockHoleCenter
+                                       -       fgkSSDCoolingBlockHoleRadius[0]
+                                       *       TMath::Sin(CoolingBlockHoleAngle*TMath::DegToRad());
+  Double_t CoolingBlockTrapezoidLength[TrapezoidNumber] = 
+                                       {       fgkSSDCoolingBlockLength,
+                                               0.5*(fgkSSDCoolingBlockLength-2.
+                                       *       (fgkSSDCoolingBlockHoleLength[1]
+                                       -       fgkSSDCoolingBlockHoleRadius[1])
+                                       -       fgkSSDCoolingBlockHoleLength[0])}; 
+  Double_t CoolingBlockTrapezoidHeigth[TrapezoidNumber] = 
+                                       {       fgkSSDCoolingBlockHeight[0]-CoolingBlockComponentHeight
+                                       -       fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
+                                       -       fgkSSDCoolingBlockHoleRadius[1],
+                                               CoolingBlockComponentHeight};
+  Double_t CoolingBlockTrapezoidWidth[TrapezoidNumber]  = 
+                                               {fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
+  //////////////////////////
+  //Vertex Positioning Shape 
+  //////////////////////////
+  CoolingBlockTrapezoidVertex[0][0] = new TVector3();
+  CoolingBlockTrapezoidVertex[0][1] = new TVector3(CoolingBlockTrapezoidLength[0]);
+  CoolingBlockTrapezoidVertex[0][2] = new TVector3(
+                                               0.5*(CoolingBlockTrapezoidVertex[0][1]->X()
+                                       -       2.*CoolingBlockTrapezoidLength[1]
+                                       -       fgkSSDCoolingBlockHoleLength[0]));
+  CoolingBlockTrapezoidVertex[0][3] = 
+                                               new TVector3(CoolingBlockTrapezoidVertex[0][1]->X()
+                                       -       CoolingBlockTrapezoidVertex[0][2]->X());
+  CoolingBlockTrapezoidVertex[1][0] = new TVector3(); 
+  CoolingBlockTrapezoidVertex[1][1] = new TVector3(CoolingBlockTrapezoidLength[1]);
+  CoolingBlockTrapezoidVertex[1][2] = 
+                                               new TVector3(CoolingBlockTrapezoidHeigth[1]
+                                       /                                CoolingBlockTrapezoidHeigth[0]
+                                       *       CoolingBlockTrapezoidVertex[0][2]->X());
+  CoolingBlockTrapezoidVertex[1][3] = 
+                                               new TVector3(CoolingBlockTrapezoidVertex[1][1]->X());
+  char* CoolingBlockTrapezoidShapeName[TrapezoidNumber] = 
+                                       {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
+  TGeoArb8* CoolingBlockTrapezoidShape[TrapezoidNumber];
+  for(Int_t i = 0; i< TrapezoidNumber; i++) CoolingBlockTrapezoidShape[i] = 
+                                               GetArbShape(CoolingBlockTrapezoidVertex[i],
+                                               CoolingBlockTrapezoidWidth,
+                                               CoolingBlockTrapezoidHeigth[i],
+                                               CoolingBlockTrapezoidShapeName[i]);
+  TGeoTranslation* CoolingBlockTrapezoidTrans = 
+                                               new TGeoTranslation("CoolingBlockTrapezoidTrans",
+                                               CoolingBlockTrapezoidVertex[0][2]->X(),
+                                               0.0,
+                                               0.5*(CoolingBlockTrapezoidHeigth[0]
+                                       +       CoolingBlockTrapezoidHeigth[1]));
+  CoolingBlockTrapezoidTrans->RegisterYourself();
+  TGeoCombiTrans* CoolingBlockTrapezoidCombiTrans = 
+                                               new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
+                                               CoolingBlockTrapezoidVertex[0][3]->X(),
+                                               fgkSSDCoolingBlockWidth,
+                                               0.5*(CoolingBlockTrapezoidHeigth[0]
+                                       +       CoolingBlockTrapezoidHeigth[1]),
+                                               new TGeoRotation("",180.,0.,0.));
+  CoolingBlockTrapezoidCombiTrans->RegisterYourself();
+  /* TGeoCompositeShape* CoolingBlockTrapezoidCompositeShape = */ 
+       new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
+       "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
+       "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans"); 
+  /////////////////////////////
+  // Cooling Block Boxes Shapes
+  /////////////////////////////
+  const Int_t BoxNumber = 3;
+  TGeoBBox* CoolingBlockBoxShape[BoxNumber];
+  CoolingBlockBoxShape[0] = new TGeoBBox("CoolingBlockBoxShape0",
+                                               0.5*fgkSSDCoolingBlockLength,
+                                               0.5*fgkSSDCoolingBlockWidth,
+                                               0.5*fgkSSDCoolingBlockHoleRadius[1]);
+  CoolingBlockBoxShape[1] = new TGeoBBox("CoolingBlockBoxShape1",
+                                               0.5*(fgkSSDCoolingBlockLength
+                                       -       2.*fgkSSDCoolingBlockHoleLength[1]),
+                                               0.5*fgkSSDCoolingBlockWidth,
+                                               0.5*fgkSSDCoolingBlockHeight[2]);
+  CoolingBlockBoxShape[2] = new TGeoBBox("CoolingBlockBoxShape2",
+                                               0.5*fgkSSDCoolingBlockLength,
+                                               0.5*fgkSSDCoolingBlockWidth,
+                                               0.5*fgkSSDCoolingBlockHeight[1]);
+  TGeoTranslation* CoolingBlockBoxTrans[BoxNumber-1];
+  CoolingBlockBoxTrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
+                                               0.5*(fgkSSDCoolingBlockHeight[1]
+                                       +       fgkSSDCoolingBlockHoleRadius[1])
+                                       +       fgkSSDCoolingBlockHeight[2]);
+  CoolingBlockBoxTrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
+                                               0.0,
+                                               0.0,
+                                               0.5*(fgkSSDCoolingBlockHeight[1]
+                                       +       fgkSSDCoolingBlockHeight[2]));
+  for(Int_t i=0; i<BoxNumber-1; i++) CoolingBlockBoxTrans[i]->RegisterYourself();
+  /* TGeoCompositeShape* CoolingBlockBoxCompositeShape = */
+       new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
+                                                  "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
+        "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
+  ///////////////////////
+  // Cooling Block Shape
+  //////////////////////
+  TGeoCombiTrans* CoolingTubeHoleShapeCombiTrans = 
+                                               new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
+                                               0.5*fgkSSDCoolingBlockLength,
+                                               0.5*fgkSSDCoolingBlockWidth,
+                                               fgkSSDCoolingBlockHoleCenter,
+                                               new TGeoRotation("",0.,90.,0.));
+  CoolingTubeHoleShapeCombiTrans->RegisterYourself();
+  TGeoTranslation* CoolingBlockTrapezoidCompositeShapeTrans = 
+                                               new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
+                                               0.0,
+                                               0.0,
+                                               0.5*CoolingBlockTrapezoidHeigth[0]+fgkSSDCoolingBlockHeight[1]+
+                                               fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
+  CoolingBlockTrapezoidCompositeShapeTrans->RegisterYourself();
+  TGeoTranslation* CoolingBlockBoxCompositeShapeTrans = 
+                                               new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
+                                               0.5*fgkSSDCoolingBlockLength,
+                                               0.5*fgkSSDCoolingBlockWidth,
+                                               0.5*fgkSSDCoolingBlockHeight[1]);
+  CoolingBlockBoxCompositeShapeTrans->RegisterYourself();
+  TGeoCompositeShape* SSDCoolingBlockShape = 
+               new TGeoCompositeShape("SSDCoolingBlockShape",  
+               "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
+               "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
+               "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
+  TGeoVolume* SSDCoolingBlock = new TGeoVolume("SSDCoolingBlock",
+               SSDCoolingBlockShape,fgkSSDAlCoolBlockMedium);
+  return SSDCoolingBlock;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  TVector3* Vertex[VertexNumber];
+  Vertex[0] = new TVector3();
+  Vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
+  Vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
+               -         fgkCarbonFiberJunctionEdge[1]
+                       *         TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
+                                 fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
+                       *     TMath::DegToRad()));
+  Vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
+                       *         TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
+                                 fgkCarbonFiberJunctionEdge[0]
+                       *         TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
+  TGeoArb8* CarbonFiberJunctionShapePiece = 
+                                               new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
+  //////////////////////////////////
+  //Setting the vertices in TGeoArb8
+  //////////////////////////////////
+  for(Int_t i = 0; i<2*VertexNumber; i++)
+       CarbonFiberJunctionShapePiece->SetVertex(i,
+                                                       Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
+                                                       Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
+  TGeoRotation* CarbonFiberJunctionRot = 
+                                               new TGeoRotation("CarbonFiberJunctionRot",
+                                                                                 180.,
+                                                                                 180.,
+                                                                                 180-2.*fgkCarbonFiberJunctionAngle[0]); 
+  TGeoVolume* CarbonFiberJunctionPiece = 
+                                               new TGeoVolume("CarbonFiberJunctionPiece",
+                                               CarbonFiberJunctionShapePiece,fgkSSDCarbonFiberMedium);
+  TGeoVolume* CarbonFiberJunction = 
+                                               new TGeoVolumeAssembly("CarbonFiberJunction");
+  CarbonFiberJunctionPiece->SetLineColor(fColorCarbonFiber);
+  CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,1);
+  CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,2,CarbonFiberJunctionRot);
+  return CarbonFiberJunction;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  SetCarbonFiberJunctionCombiTransMatrix();
+  TGeoVolume* CarbonFiberJunctionAssembly = 
+                                                 new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
+  TGeoVolume* CarbonFiberJunction = 
+                                                 GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
+  for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++) 
+    CarbonFiberJunctionAssembly->AddNode(CarbonFiberJunction,i+1,
+                                                                                CarbonFiberJunctionCombiTransMatrix[i]);
+  return CarbonFiberJunctionAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t SSDEndLadderCableLength){
+/////////////////////////////////////////////////////////////////////////////////
+const Int_t LadderCableSegmentNumber = 2;
+/////////////////////////////////////////
+// LadderSegmentBBox Volume
+/////////////////////////////////////////
+  TGeoBBox* LadderCableSegmentBBoxShape[LadderCableSegmentNumber];
+  const char* LadderCableSegmentBBoxShapeName[LadderCableSegmentNumber] = 
+                               {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderCableSegmentBBoxShape[i] = 
+                                                 new TGeoBBox(LadderCableSegmentBBoxShapeName[i],
+                                                                          0.5*fgkSSDFlexWidth[0],
+                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                          0.5*fgkSSDFlexHeight[i]); 
+  const char* LadderCableSegmentBBoxName[LadderCableSegmentNumber] = 
+                                                 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
+  TGeoVolume* LadderCableSegmentBBox[LadderCableSegmentNumber];
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++){ 
+                       LadderCableSegmentBBox[i] =
+                                                 new TGeoVolume(LadderCableSegmentBBoxName[i],
+                                                                                LadderCableSegmentBBoxShape[i],
+                                                                                (i==0?fgkSSDAlTraceLadderCableMedium:
+            fgkSSDKaptonLadderCableMedium));
+                       LadderCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl : 
+                                                                                                                  fColorPolyhamide);
+  }
+  TGeoTranslation* LadderCableSegmentBBoxTrans[LadderCableSegmentNumber];                                                                                
+  LadderCableSegmentBBoxTrans[0] = 
+                                                  new TGeoTranslation("LadderCableSegmentBBoxTrans1",
+                                                                                          0.5*fgkSSDFlexWidth[0],
+                                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                                          0.5*fgkSSDFlexHeight[0]);
+  LadderCableSegmentBBoxTrans[1] = 
+                                                  new TGeoTranslation("LadderCableSegmentBBoxTrans2",
+                                                                                          0.5*fgkSSDFlexWidth[0],
+                                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                                          fgkSSDFlexHeight[0]
+                                                                                          +0.5*fgkSSDFlexHeight[1]);
+  TGeoVolume* LadderCableSegmentBBoxAssembly = 
+                                                  new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly"); 
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++)  
+               LadderCableSegmentBBoxAssembly->AddNode(LadderCableSegmentBBox[i],1,
+                                                                                           LadderCableSegmentBBoxTrans[i]);
+/////////////////////////////////////////
+// LadderSegmentArb8 Volume
+/////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  TVector3** LadderCableSegmentVertexPosition[LadderCableSegmentNumber];
+  for(Int_t i = 0; i<LadderCableSegmentNumber; i++) LadderCableSegmentVertexPosition[i] = 
+                                                                                                 new TVector3*[VertexNumber];
+//Shape Vertex Positioning
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++){
+       LadderCableSegmentVertexPosition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
+       LadderCableSegmentVertexPosition[i][1] = new TVector3(fgkSSDLadderCableWidth,
+                                                                                                                 i*fgkSSDFlexHeight[0]);
+       LadderCableSegmentVertexPosition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
+                                                                                  +                         fgkSSDFlexHeight[1]
+                                                                                  +                      i*fgkSSDFlexHeight[0]);
+       LadderCableSegmentVertexPosition[i][3] = 
+                                                  new TVector3(LadderCableSegmentVertexPosition[i][1]->X(),
+                                                                               LadderCableSegmentVertexPosition[i][2]->Y());
+  }
+  Double_t LadderCableSegmentWidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
+                                                                           {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}}; 
+  char* LadderCableSegmentArbShapeName[LadderCableSegmentNumber] = 
+                                       {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
+  TGeoArb8* LadderCableSegmentArbShape[LadderCableSegmentNumber];
+  for(Int_t i = 0; i< LadderCableSegmentNumber; i++) LadderCableSegmentArbShape[i] = 
+                                       GetArbShape(LadderCableSegmentVertexPosition[i],
+                                                               LadderCableSegmentWidth[i],
+                                                               fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
+                                                               LadderCableSegmentArbShapeName[i]);
+  const char* LadderCableSegmentArbName[LadderCableSegmentNumber] = 
+                                                 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
+  TGeoVolume* LadderCableSegmentArb[LadderCableSegmentNumber];
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++){
+                        LadderCableSegmentArb[i] =
+                                                  new TGeoVolume(LadderCableSegmentArbName[i],
+                                                                                 LadderCableSegmentArbShape[i],
+                                                                                 (i==0?fgkSSDAlTraceLadderCableMedium:
+            fgkSSDKaptonLadderCableMedium)); 
+                        LadderCableSegmentArb[i]->SetLineColor(i==0 ? fColorAl : 
+                                                                                                                  fColorPolyhamide);
+}
+  TGeoRotation* LadderCableSegmentArbRot[LadderCableSegmentNumber];
+  LadderCableSegmentArbRot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
+                                                                                                90.,90,-90.);   
+  LadderCableSegmentArbRot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
+                                                                                                 0.,90.,0.);    
+  TGeoCombiTrans* LadderCableSegmentArbCombiTrans =  
+                                                  new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
+                                                          0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
+                                                        + fgkSSDFlexWidth[0],0.,0.,
+                                                  new TGeoRotation((*LadderCableSegmentArbRot[1])
+                                                    *(*LadderCableSegmentArbRot[0])));
+  TGeoVolume* LadderCableSegmentArbAssembly = 
+                                                  new TGeoVolumeAssembly("LadderCableSegmentArbAssembly"); 
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++)
+  LadderCableSegmentArbAssembly->AddNode(LadderCableSegmentArb[i],1,
+                                                                                  LadderCableSegmentArbCombiTrans);
+/////////////////////////////////////////
+// End Ladder Cable Volume
+/////////////////////////////////////////
+  TGeoBBox* LadderEndCableSegmentBBoxShape[LadderCableSegmentNumber];
+  const char* LadderEndCableSegmentBBoxShapeName[LadderCableSegmentNumber] = 
+                               {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderEndCableSegmentBBoxShape[i] = 
+                                                 new TGeoBBox(LadderEndCableSegmentBBoxShapeName[i],
+                                                                          0.5*SSDEndLadderCableLength,
+                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                          0.5*fgkSSDFlexHeight[i]);
+  const char* LadderEndCableSegmentBBoxName[LadderCableSegmentNumber] = 
+                                                 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
+  TGeoVolume* LadderEndCableSegmentBBox[LadderCableSegmentNumber];
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++){ 
+                       LadderEndCableSegmentBBox[i] =
+                                                 new TGeoVolume(LadderEndCableSegmentBBoxName[i],
+                                                                                LadderEndCableSegmentBBoxShape[i],
+                                                                                (i==0?fgkSSDAlTraceLadderCableMedium:
+            fgkSSDKaptonLadderCableMedium));
+                       LadderEndCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl : 
+                                                                                                                  fColorPolyhamide);
+  }
+  TGeoTranslation* LadderEndCableSegmentBBoxTrans[LadderCableSegmentNumber];                                                                             
+  LadderEndCableSegmentBBoxTrans[0] = 
+                                                  new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
+                                                                                          0.5*SSDEndLadderCableLength,
+                                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                                          0.5*fgkSSDFlexHeight[0]);
+  LadderEndCableSegmentBBoxTrans[1] = 
+                                                  new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
+                                                                                          0.5*SSDEndLadderCableLength,
+                                                                                          0.5*fgkSSDLadderCableWidth,
+                                                                                          fgkSSDFlexHeight[0]
+                                                                                          +0.5*fgkSSDFlexHeight[1]);
+  TGeoVolume* LadderEndCableSegmentBBoxAssembly = 
+                                                  new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly"); 
+  for(Int_t i=0; i<LadderCableSegmentNumber; i++)  
+               LadderEndCableSegmentBBoxAssembly->AddNode(LadderEndCableSegmentBBox[i],1,
+                                                                                           LadderEndCableSegmentBBoxTrans[i]);
+/////////////////////////////////////////
+  TList* LadderCableSegmentList = new TList();
+  LadderCableSegmentList->Add(LadderCableSegmentBBoxAssembly);
+  LadderCableSegmentList->Add(LadderCableSegmentArbAssembly);
+  LadderCableSegmentList->Add(LadderEndCableSegmentBBoxAssembly);
+  return LadderCableSegmentList;
+  }
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t SSDEndLadderCableLength){
+/////////////////////////////////////////////////////////////////////////////////
+  TList* LadderCableSegmentList = GetLadderCableSegment(SSDEndLadderCableLength);
+  TGeoVolume* LadderCable = new TGeoVolumeAssembly("LadderCable"); 
+  for(Int_t i=0; i<n; i++){
+       TGeoTranslation* LadderCableTrans = new TGeoTranslation(
+                                                       i*(fgkCarbonFiberJunctionWidth),
+                                                       fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
+                                                       i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
+    LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(0),i+1,LadderCableTrans);  
+       if(i!=n-1) LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(1),i+1,LadderCableTrans);  
+  }
+  TGeoTranslation* EndLadderCableTrans = new TGeoTranslation("EndLadderCableTrans",
+                                         (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
+                                                                fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
+                                         (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
+  LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(2),1,EndLadderCableTrans);
+  return LadderCable;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t SSDEndLadderCableLength){
+/////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* LadderCableAssembly = new TGeoVolumeAssembly("LadderCableAssembly");
+  char LadderCableTransName[30];
+  for(Int_t i=0; i<n; i++){ 
+       sprintf(LadderCableTransName,"LadderCableTrans%i",i+1);
+    LadderCableAssembly->AddNode(GetLadderCable(n-i,SSDEndLadderCableLength),i+1,
+       new TGeoTranslation(LadderCableTransName,i*fgkCarbonFiberJunctionWidth,0.,0.));
+  }
+  return LadderCableAssembly;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t SSDEndLadderCableLength){
+/////////////////////////////////////////////////////////////////////////////////
+  const Int_t LadderCableAssemblyNumber = 2;
+  TGeoVolume* LadderCableAssembly = GetLadderCableAssembly(n,SSDEndLadderCableLength);
+  TGeoVolume* LadderCable[LadderCableAssemblyNumber];
+  char LadderCableAssemblyName[30];
+  TList* LadderCableAssemblyList = new TList();
+  for(Int_t i=0; i<LadderCableAssemblyNumber; i++){ 
+       sprintf(LadderCableAssemblyName,"LadderCableAssembly%i",i+1);
+       LadderCable[i] = new TGeoVolumeAssembly(LadderCableAssemblyName);
+       LadderCable[i]->AddNode(LadderCableAssembly,i+1,i==0 ? NULL :
+                                        new TGeoCombiTrans((n-1)
+                                        *       fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
+                                            2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
+                                                                                       0.,new TGeoRotation("",180,0.,0.)));
+       LadderCableAssemblyList->Add(LadderCable[i]);
+}
+  return LadderCableAssemblyList;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t EndLabberCarbonFiberJunctionNumber = 2;
+  TGeoVolume* EndLadderCarbonFiberJunctionAssembly[EndLabberCarbonFiberJunctionNumber];
+  EndLadderCarbonFiberJunctionAssembly[0] = 
+                               new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
+  EndLadderCarbonFiberJunctionAssembly[1] = 
+                               new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
+  TGeoVolume** EndLadderCarbonFiberJunction[EndLabberCarbonFiberJunctionNumber];
+  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++) 
+                                                  EndLadderCarbonFiberJunction[i] = new TGeoVolume*[2];
+  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
+    EndLadderCarbonFiberJunction[i][0] = 
+                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
+    EndLadderCarbonFiberJunction[i][1] = 
+                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
+  }
+  TList* EndLadderCarbonFiberJunctionList = new TList();
+  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
+    SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
+    for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
+      EndLadderCarbonFiberJunctionAssembly[i]->AddNode(j==2 ? 
+                                                EndLadderCarbonFiberJunction[i][1] : 
+                                                EndLadderCarbonFiberJunction[i][0],
+                                                j+1,EndLadderCarbonFiberJunctionCombiTransMatrix[j]);
+    EndLadderCarbonFiberJunctionList->Add(EndLadderCarbonFiberJunctionAssembly[i]);
+  }
+  return EndLadderCarbonFiberJunctionList;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  const Int_t ShapesNumber = 2;
+  TVector3** VertexPosition[ShapesNumber];
+  for(Int_t i=0; i<ShapesNumber; i++) VertexPosition[i] = new TVector3*[VertexNumber];
+  Double_t CarbonFiberSupportXAxisEdgeProj = 
+               fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
+       *       TMath::DegToRad());
+  Double_t Theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
+                                /                         fgkCarbonFiberSupportXAxisLength);
+  /////////////////////
+  //Vertex Positioning
+  ////////////////////
+  VertexPosition[0][0] = new TVector3();
+  VertexPosition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
+                                                                         fgkCarbonFiberSupportYAxisLength);
+  VertexPosition[0][2] = new TVector3(CarbonFiberSupportXAxisEdgeProj,
+                                                                         CarbonFiberSupportXAxisEdgeProj
+                                          *                      TMath::Tan(Theta));
+  VertexPosition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
+                                          -                      CarbonFiberSupportXAxisEdgeProj,
+                                                                         fgkCarbonFiberSupportYAxisLength
+                                          -                      VertexPosition[0][2]->Y());
+  ////////////////////////////////////////////////////
+  //Setting the parameters for Isometry Transformation
+  ////////////////////////////////////////////////////
+  Double_t SymmetryPlanePosition = (fgkCarbonFiberSupportYAxisLength
+                                                                +      fgkCarbonFiberSupportTopEdgeDist[0]
+                                                                +      fgkCarbonFiberSupportWidth);
+  Double_t* param = new Double_t[4]; 
+  param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -SymmetryPlanePosition;
+  for(Int_t j=0; j<VertexNumber; j++) VertexPosition[1][j] = 
+                                 new TVector3((GetReflection(VertexPosition[0][j],param))->X(),
+                                                         (GetReflection(VertexPosition[0][j],param))->Y());
+  char* CarbonFiberSupportShapeName[ShapesNumber] = 
+                                               {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
+  TGeoArb8* CarbonFiberSupportShape[ShapesNumber]; 
+  Double_t Width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
+  Double_t CarbonFiberSupportHeight = 
+         CarbonFiberSupportXAxisEdgeProj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
+         *TMath::DegToRad());
+  for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberSupportShape[i] = 
+                                       GetArbShape(VertexPosition[i],Width,CarbonFiberSupportHeight,
+                                                                       CarbonFiberSupportShapeName[i],i==0 ? 1: -1);
+  /////////////////////////////////////
+  //Setting Translations and Rotations: 
+  /////////////////////////////////////
+  TGeoTranslation* CarbonFiberSupportTrans = 
+                                                 new TGeoTranslation("CarbonFiberSupportTrans",
+                                                                                         0.0,0.0,0.5*CarbonFiberSupportHeight);
+  CarbonFiberSupportTrans->RegisterYourself();
+  TGeoRotation* CarbonFiberCompShapeRot[2];
+  CarbonFiberCompShapeRot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
+                                                                                         0.0,180.0,0.0);
+  CarbonFiberCompShapeRot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
+                                                                                 90.,-fgkCarbonFiberTriangleAngle,-90.);
+  Double_t TransVector[3] = {fgkCarbonFiberTriangleLength
+                                                 *  TMath::Cos(fgkCarbonFiberTriangleAngle
+                                                 *      TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
+                                                 *      TMath::Sin(fgkCarbonFiberTriangleAngle
+                                                 *      TMath::DegToRad())};
+  TGeoCombiTrans* CarbonFiberSupportCombiTrans = 
+                                                          new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
+                                                          TransVector[0],2.*SymmetryPlanePosition
+                                                 +        TransVector[1],TransVector[2],
+                                                          new TGeoRotation((*CarbonFiberCompShapeRot[1])
+                                                 *        (*CarbonFiberCompShapeRot[0])));
+  CarbonFiberSupportCombiTrans->RegisterYourself();
+////////////////////////////////////////////////////////////////////////////////
+  TGeoCompositeShape* CarbonFiberSupportCompShape = 
+                                                       new TGeoCompositeShape("CarbonFiberSupportCompShape",
+                                                       "CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
+                                                       "CarbonFiberSupportShape2:CarbonFiberSupportTrans");
+  TGeoVolume* CarbonFiberSupport = new TGeoVolume("CarbonFiberSupport",
+                                                  CarbonFiberSupportCompShape,fgkSSDCarbonFiberMedium);
+  CarbonFiberSupport->SetLineColor(fColorCarbonFiber);
+  TGeoVolume* CarbonFiberSupportAssembly = 
+                                                   new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
+  CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,1);
+  CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,2,
+                                                                         CarbonFiberSupportCombiTrans);
+  return CarbonFiberSupportAssembly;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  const Int_t ShapesNumber = 2;
+  Double_t Width[2] = {fgkCarbonFiberLowerSupportWidth,
+                                                               fgkCarbonFiberLowerSupportWidth};
+  TVector3** VertexPosition[ShapesNumber];
+  for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] = 
+                                                new TVector3*[VertexNumber];
+  //First Shape Vertex Positioning
+  VertexPosition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
+  VertexPosition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
+                                          -            fgkCarbonFiberLowerSupportLowerLenght);
+  VertexPosition[0][2] = new TVector3();
+  VertexPosition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
+  //Second Shape Vertex Positioning
+  Double_t Theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
+                                -                              fgkCarbonFiberLowerSupportVolumePosition[0])
+                                /                              fgkCarbonFiberTriangleLength);
+  VertexPosition[1][0] = new TVector3(VertexPosition[0][0]->X(),
+                                                               VertexPosition[0][0]->X()*TMath::Tan(Theta)
+                                +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
+  VertexPosition[1][1] = new TVector3(VertexPosition[0][1]->X(),
+                                                               VertexPosition[0][1]->X()*TMath::Tan(Theta)
+                                +                              fgkCarbonFiberLowerSupportVolumePosition[0]);
+  VertexPosition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
+  VertexPosition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
+                                                               fgkCarbonFiberLowerSupportVolumePosition[1]);
+  char* CarbonFiberLowerSupportName[ShapesNumber] = 
+                         {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
+  TGeoArb8* CarbonFiberLowerSupportShape[ShapesNumber];
+  for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberLowerSupportShape[i] = 
+                                                               GetArbShape(VertexPosition[i],Width,
+                                                                                       fgkCarbonFiberLowerSupportHeight,
+                                                                                       CarbonFiberLowerSupportName[i]);
+  ///////////////////////////////////////////////////////
+  TGeoTranslation* CarbonFiberLowerSupportTrans[ShapesNumber];
+  CarbonFiberLowerSupportTrans[0] = 
+                                               new TGeoTranslation("CarbonFiberLowerSupportTrans1",
+                                               0.0,
+                                               VertexPosition[1][3]->Y()+VertexPosition[1][2]->Y(),
+                                               0.0);
+  CarbonFiberLowerSupportTrans[1] = 
+                                               new TGeoTranslation("CarbonFiberLowerSupportTrans2",
+                                               0.0,
+                               -               VertexPosition[1][3]->Y()-VertexPosition[1][2]->Y(),
+                                               0.0);
+  for(Int_t i = 0; i< ShapesNumber; i++) 
+                                               CarbonFiberLowerSupportTrans[i]->RegisterYourself(); 
+  ///////////////////////////////////////////////////////
+  TGeoCompositeShape* CarbonFiberLowerSupportCompShape; 
+  if(EndLadder==false)
+    CarbonFiberLowerSupportCompShape = 
+                               new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
+                               "CarbonFiberLowerSupportShape2+"
+                               "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
+  else
+    if(ikind==0)
+      CarbonFiberLowerSupportCompShape = 
+                                                 (TGeoCompositeShape*)CarbonFiberLowerSupportShape[0];
+    else
+      CarbonFiberLowerSupportCompShape = 
+       new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
+                                "CarbonFiberLowerSupportShape1+"
+                                "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1"); 
+  TGeoVolume* CarbonFiberLowerSupport = new TGeoVolume("CarbonFiberLowerSupport",
+                                         CarbonFiberLowerSupportCompShape,fgkSSDCarbonFiberMedium);
+  CarbonFiberLowerSupport->SetLineColor(fColorCarbonFiber);
+  return CarbonFiberLowerSupport;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
+////////////////////////////////////////////////////////////////////////////////
+  SetCarbonFiberAssemblyCombiTransMatrix();
+  TGeoVolume* CarbonFiberAssemblySupport = 
+                                               new TGeoVolumeAssembly("CarbonFiberAssembly");
+  TGeoVolume* CarbonFiberAssemblyVolumes[fgkCarbonFiberAssemblyCombiTransNumber];
+  CarbonFiberAssemblyVolumes[0] = GetCarbonFiberJunctionAssembly();
+  CarbonFiberAssemblyVolumes[1] = GetCarbonFiberSupport();
+  CarbonFiberAssemblyVolumes[2] = GetCarbonFiberLowerSupport();
+  for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++) 
+    CarbonFiberAssemblySupport->AddNode(CarbonFiberAssemblyVolumes[i],1,
+                                               CarbonFiberAssemblyCombiTransMatrix[i]);
+  return CarbonFiberAssemblySupport;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 3;
+  Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
+                          /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
+  /* TGeoTubeSeg* CoolingTubeSegShape =  */ 
+                                               new TGeoTubeSeg("CoolingTubeSegShape",0.0,
+                                                       fgkCoolingTubeSupportRmax,
+                                                       0.5*fgkCoolingTubeSupportWidth,Phi,
+                                                       360-Phi);
+  /* TGeoTube* CoolingTubeHoleShape =  */
+                                               new TGeoTube("CoolingTubeHoleShape",0.0,
+                                                       fgkCoolingTubeSupportRmin,
+                                                       0.5*fgkCoolingTubeSupportWidth);
+  TVector3* VertexPosition[VertexNumber];
+  ///////////////////////////
+  //Shape Vertex Positioning
+  ///////////////////////////
+  VertexPosition[0] = new TVector3();
+  VertexPosition[1] = new TVector3(fgkCoolingTubeSupportRmax
+                                       *               TMath::Cos(Phi*TMath::DegToRad()),
+                                                       fgkCoolingTubeSupportRmax
+                                       *               TMath::Sin(Phi*TMath::DegToRad()));
+  VertexPosition[2] = new TVector3(VertexPosition[1]->X(),
+                                       -                          VertexPosition[1]->Y());
+  /* TGeoArb8* CoolingTubeTriangleShape = */ GetTriangleShape(VertexPosition,
+                                                                          fgkCoolingTubeSupportWidth,
+                                                                          "CoolingTubeTriangleShape");
+  Double_t* BoxOrigin = new Double_t[3];
+  Double_t BoxLength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
+                                        - VertexPosition[1]->X();
+  BoxOrigin[0] = VertexPosition[1]->X()+0.5*BoxLength, BoxOrigin[1] = BoxOrigin[2] = 0.;
+  /* TGeoBBox* CoolingTubeBoxShape = */
+                                               new TGeoBBox("CoolingTubeBoxShape",0.5*BoxLength,
+                                                       0.5*fgkCoolingTubeSupportHeight,
+                                                       0.5*fgkCoolingTubeSupportWidth,BoxOrigin);
+  TGeoCompositeShape* CoolingTubeSupportShape = 
+                                               new TGeoCompositeShape("CoolingTubeSupportShape",
+                                                "(CoolingTubeSegShape+CoolingTubeTriangleShape"
+                                                "+CoolingTubeBoxShape)-CoolingTubeHoleShape"); 
+  TGeoVolume* CoolingTubeSupport = new TGeoVolume("CoolingTubeSupport",
+                                                CoolingTubeSupportShape,fgkSSDTubeHolderMedium);
+  return CoolingTubeSupport;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* CoolingTubeSupportAssembly = 
+                                                  new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
+  TGeoVolume* CoolingTubeSupport = GetCoolingTubeSupport();
+  SetCoolingTubeSupportCombiTransMatrix();
+  for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++) 
+    CoolingTubeSupportAssembly->AddNode(CoolingTubeSupport,i+1,
+                                                                                CoolingTubeSupportCombiTransMatrix[i]);
+  return CoolingTubeSupportAssembly;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube(){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* CoolingTubeAssembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
+  TGeoTube *CoolingTubeShape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin, 
+                                               fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
+  TGeoVolume* CoolingTube = new TGeoVolume("CoolingTube",
+                                                CoolingTubeShape,fgkSSDCoolingTubePhynox);
+  TGeoTube *CoolingTubeInteriorShape = new TGeoTube("CoolingTubeInteriorShape", 
+                                               0, fgkCoolingTubeRmin, 
+                                               fgkCoolingTubeLength/2.0);
+  TGeoVolume *CoolingTubeInterior = new TGeoVolume("CoolingTubeInterior",
+                                                  CoolingTubeInteriorShape,fgkSSDCoolingTubeWater);
+  CoolingTubeAssembly->AddNode(CoolingTube,1);
+  CoolingTubeAssembly->AddNode(CoolingTubeInterior,2);
+  return CoolingTubeAssembly;
+}  
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
+////////////////////////////////////////////////////////////////////////////////
+  TGeoVolume* CoolingTubeAssembly =   new TGeoVolumeAssembly("CoolingTubeAssembly");
+  TGeoVolume* CoolingTube = GetCoolingTube();
+  SetCoolingTubeCombiTransMatrix();
+  for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++) 
+    CoolingTubeAssembly->AddNode(CoolingTube,i+1,CoolingTubeTransMatrix[i]);
+  return CoolingTubeAssembly;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
+////////////////////////////////////////////////////////////////////////////////
+    TGeoVolume* LadderSegment = new TGeoVolumeAssembly("LadderSegment");
+    TGeoVolume* LadderSegmentVolumes[fgkLadderSegmentCombiTransNumber];
+    LadderSegmentVolumes[0] = GetCarbonFiberAssemblySupport();
+    LadderSegmentVolumes[1] = GetSSDModule(iChipCablesHeight);
+    LadderSegmentVolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
+    LadderSegmentVolumes[3] = GetCoolingTubeSupportAssembly();
+       LadderSegmentVolumes[4] = GetCoolingTubeAssembly(); 
+    SetLadderSegmentCombiTransMatrix();
+    for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) 
+      LadderSegment->AddNode(LadderSegmentVolumes[i],1,
+                                                        LadderSegmentCombiTransMatrix[i]);
+    return LadderSegment;
+}
+////////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t EndLadderSegmentNumber = 2;
+  TList* EndLadderCarbonFiberJunctionList = GetEndLadderCarbonFiberJunctionAssembly();
+  TGeoVolume* EndLadderSegment[EndLadderSegmentNumber];
+  EndLadderSegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
+  EndLadderSegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
+  TGeoVolume** LadderSegmentVolumes[EndLadderSegmentNumber];
+  const Int_t LadderSegmentVolumeNumber = 4;
+  for(Int_t i=0; i<EndLadderSegmentNumber; i++) LadderSegmentVolumes[i] = 
+                                               new TGeoVolume*[LadderSegmentVolumeNumber];
+  LadderSegmentVolumes[0][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(0);
+  LadderSegmentVolumes[0][1] = GetCarbonFiberSupport();
+  LadderSegmentVolumes[0][2] = GetSSDMountingBlock();
+  LadderSegmentVolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
+  LadderSegmentVolumes[1][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(1);
+  LadderSegmentVolumes[1][1] = LadderSegmentVolumes[0][1];
+  LadderSegmentVolumes[1][2] = LadderSegmentVolumes[0][2];
+  LadderSegmentVolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
+  TList* EndLadderSegmentList = new TList();
+  for(Int_t i=0; i<EndLadderSegmentNumber; i++){
+    SetEndLadderSegmentCombiTransMatrix(i);
+    for(Int_t j=0; j<LadderSegmentVolumeNumber; j++)
+      EndLadderSegment[i]->AddNode(LadderSegmentVolumes[i][j],1,
+                                                                  EndLadderSegmentCombiTransMatrix[j]);
+    EndLadderSegmentList->Add(EndLadderSegment[i]);
+  }
+  return EndLadderSegmentList;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
+////////////////////////////////////////////////////////////////////////////////
+  // Mounting Block Boxes Shapes
+  ///////////////////////////////////////
+  const Int_t MountingBlockBoxNumber = 3;
+  TGeoBBox* MountingBlockBoxShape[MountingBlockBoxNumber];
+  MountingBlockBoxShape[0] = new TGeoBBox("MountingBlockBoxShape0",
+                                                       0.25*(fgkSSDMountingBlockLength[0]
+                                               -       fgkSSDMountingBlockLength[1]),
+                                                       0.5*fgkSSDMountingBlockWidth,
+                                                       0.5*fgkSSDMountingBlockHeight[0]);
+  MountingBlockBoxShape[1] = new TGeoBBox("MountingBlockBoxShape1",
+                                                       0.25*(fgkSSDMountingBlockLength[1]
+                                               -       fgkSSDMountingBlockLength[2]),
+                                                       0.5*fgkSSDMountingBlockWidth,
+                                                       0.5*(fgkSSDMountingBlockHeight[1]
+                                               -       fgkSSDMountingBlockHeight[3]));
+  MountingBlockBoxShape[2] = new TGeoBBox("MountingBlockBoxShape2",
+                                                       0.5*fgkSSDMountingBlockLength[2],
+                                                       0.5*fgkSSDMountingBlockWidth,
+                                                       0.5*(fgkSSDMountingBlockHeight[2]
+                                               -       fgkSSDMountingBlockHeight[3]));
+  TGeoTranslation* MountingBlockBoxTrans[MountingBlockBoxNumber+2];
+  MountingBlockBoxTrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
+  MountingBlockBoxTrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
+                                                       MountingBlockBoxShape[0]->GetDX()
+                                               +       MountingBlockBoxShape[1]->GetDX(),
+                                                       0.0,
+                                                       MountingBlockBoxShape[1]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3]);
+  MountingBlockBoxTrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
+                                                       MountingBlockBoxShape[0]->GetDX()
+                                               +       2.*MountingBlockBoxShape[1]->GetDX()
+                                               +       MountingBlockBoxShape[2]->GetDX(),
+                                                       0.0,
+                                                       MountingBlockBoxShape[2]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3]);
+  MountingBlockBoxTrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
+                                                       MountingBlockBoxShape[0]->GetDX()
+                                               +       MountingBlockBoxShape[1]->GetDX()
+                                               +       2.*(MountingBlockBoxShape[1]->GetDX()
+                                               +       MountingBlockBoxShape[2]->GetDX()),
+                                                       0.0,
+                                                       MountingBlockBoxShape[1]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3]);
+  MountingBlockBoxTrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
+                                                       2.*(MountingBlockBoxShape[0]->GetDX()
+                                               +       2.*MountingBlockBoxShape[1]->GetDX()
+                                               +   MountingBlockBoxShape[2]->GetDX()),
+                                                       0.0,
+                                                       0.0);
+  for(Int_t i=0; i<MountingBlockBoxNumber+2; i++) 
+                                                                       MountingBlockBoxTrans[i]->RegisterYourself();
+  ///////////////////////////////////////
+  // Mounting Block Trapezoid Hole Shapes
+  ///////////////////////////////////////
+  const Int_t HoleTrapezoidVertexNumber = 4;
+  TVector3* HoleTrapezoidVertex[HoleTrapezoidVertexNumber];
+  HoleTrapezoidVertex[0] = new TVector3();
+  HoleTrapezoidVertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
+  HoleTrapezoidVertex[2] = new TVector3(*HoleTrapezoidVertex[0]);
+  HoleTrapezoidVertex[3] = new TVector3(*HoleTrapezoidVertex[1]);
+  Double_t HoleTrapezoidWidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
+                                               +       2.*MountingBlockBoxShape[1]->GetDX()
+                                               *       TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
+                                               *       TMath::DegToRad()),
+                                                       fgkSSDMountingBlockHoleTrapezoidUpBasis}; 
+  /* TGeoArb8* HoleTrapezoidShape =*/ GetArbShape(HoleTrapezoidVertex,
+                                                       HoleTrapezoidWidth,
+                                                       2.*MountingBlockBoxShape[1]->GetDX(),
+                                                       "HoleTrapezoidShape");
+  TGeoRotation* HoleTrapezoidShapeRot[2];
+  HoleTrapezoidShapeRot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
+                                                       90.,-90.,-90.);
+  HoleTrapezoidShapeRot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
+                                                       -180.,0.,0.);
+  TGeoCombiTrans* HoleTrapezoidShapeCombiTrans = 
+                                                       new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
+                                                       MountingBlockBoxShape[0]->GetDX()
+                                               +       3.*MountingBlockBoxShape[1]->GetDX()
+                                               +       2.*MountingBlockBoxShape[2]->GetDX(),
+                                                       0.5*fgkSSDMountingBlockWidth,
+                                               -       fgkSSDMountingBlockHoleTrapezoidHeight
+                                               +       2.*MountingBlockBoxShape[1]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3],
+                                                       new TGeoRotation((*HoleTrapezoidShapeRot[1])
+                                               *       (*HoleTrapezoidShapeRot[0])));
+  HoleTrapezoidShapeCombiTrans->RegisterYourself();
+  ///////////////////////////////////
+  // Mounting Block Screw Hole Shapes
+  ///////////////////////////////////
+  const Int_t MountingBlockTubeNumber = 2;
+  TGeoTube* MountingBlockTubeShape[MountingBlockTubeNumber];
+  MountingBlockTubeShape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
+                                                       fgkSSDMountingBlockHoleRadius,
+                                                       MountingBlockBoxShape[0]->GetDZ());
+  MountingBlockTubeShape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
+                                                       fgkSSDMountingBlockHoleRadius,
+                                                       MountingBlockBoxShape[2]->GetDZ());
+  TGeoTranslation* MountingBlockTubeTrans[2*MountingBlockTubeNumber];
+  MountingBlockTubeTrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
+                                               -       0.5*(fgkSSDMountingBlockLength[0]
+                                               -       fgkSSDMountingBlockHoleTubeLength[0]),
+                                                       0.5*fgkSSDMountingBlockWidth
+                                               -       fgkSSDMountingBlockHoleTubeWidth[0],0.);
+  MountingBlockTubeTrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
+                                               -       0.5*(fgkSSDMountingBlockLength[0]
+                                               -       fgkSSDMountingBlockHoleTubeLength[0])
+                                               +       fgkSSDMountingBlockHoleTubeLength[0],
+                                               -       0.5*fgkSSDMountingBlockWidth
+                                               +       fgkSSDMountingBlockHoleTubeWidth[0],
+                                                       0.);
+  MountingBlockTubeTrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
+                                               -       MountingBlockBoxShape[0]->GetDX()
+                                               +       0.5*fgkSSDMountingBlockLength[0]
+                                               -       fgkSSDMountingBlockHoleTubeLength[1],
+                                                       0.5*fgkSSDMountingBlockWidth
+                                               -       fgkSSDMountingBlockHoleTubeWidth[0],
+                                                       MountingBlockBoxShape[2]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3]);
+  MountingBlockTubeTrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
+                                               -       MountingBlockBoxShape[0]->GetDX()
+                                               +       0.5*fgkSSDMountingBlockLength[0],
+                                               -       0.5*fgkSSDMountingBlockWidth
+                                               +       fgkSSDMountingBlockHoleTubeWidth[1],
+                                                       MountingBlockBoxShape[2]->GetDZ()
+                                               -       MountingBlockBoxShape[0]->GetDZ()
+                                               +       fgkSSDMountingBlockHeight[3]);
+  for(Int_t i=0; i<2*MountingBlockTubeNumber; i++) 
+                                               MountingBlockTubeTrans[i]->RegisterYourself();
+  /* TGeoCompositeShape* MountingBlockMainShape = */
+                                               new TGeoCompositeShape("MountingBlockMainShape",
+                                               "MountingBlockBoxShape0:MountingBlockBoxTrans0+"
+                                               "MountingBlockBoxShape1:MountingBlockBoxTrans1+"
+                                               "MountingBlockBoxShape2:MountingBlockBoxTrans2+"
+                                               "MountingBlockBoxShape1:MountingBlockBoxTrans3+"
+                                               "MountingBlockBoxShape0:MountingBlockBoxTrans4");
+  ////////////////////////////////////////////
+  // Mounting Block Screw Composite Hole Shapes
+  ////////////////////////////////////////////
+  const Int_t MountingBlockHoleTubeSegNumber = 4;
+  /* TGeoTubeSeg* MountingBlockHoleTubeSegShape =  */ 
+                                               new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
+                                               0.0,
+                                               fgkSSDMountingBlockScrewHoleRadius[0],
+                                               0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
+  TGeoCombiTrans* MountingBlockHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
+  char* MountingBlockHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] = 
+                                       {       "MountingBlockHoleTubeSegCombiTrans0",
+                                               "MountingBlockHoleTubeSegCombiTrans1",
+                                               "MountingBlockHoleTubeSegCombiTrans2",
+                                               "MountingBlockHoleTubeSegCombiTrans3"};
+  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
+    MountingBlockHoleTubeSegCombiTrans[i] =
+      new TGeoCombiTrans(MountingBlockHoleTubeSegCombiTransName[i],
+                                               0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
+                                       *       TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
+                                               0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
+                                       *       TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
+                                               0.0,
+                                               new TGeoRotation("",90.*i,0.,0.));
+    MountingBlockHoleTubeSegCombiTrans[i]->RegisterYourself();
+  }
+  TGeoBBox* MountingBlockHoleBoxShape = 
+                                               new TGeoBBox("MountingBlockHoleBoxShape",
+                                               0.5*fgkSSDMountingBlockScrewHoleEdge,
+                                               0.5*fgkSSDMountingBlockScrewHoleEdge,
+                                               0.5*fgkSSDMountingBlockScrewHoleHeigth);
+  TGeoCompositeShape* MountingBlockScrewHole[2];
+  MountingBlockScrewHole[0] = 
+                       new TGeoCompositeShape("MountingBlockScrewHole0",
+                       "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
+                       "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
+                       "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
+                       "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
+                       "MountingBlockHoleBoxShape");
+  /* TGeoTubeSeg* MountingBlockLowerHoleTubeSegShape = */
+                       new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
+                                               0.0,
+                                               fgkSSDMountingBlockScrewHoleRadius[1],
+                                               0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
+                                       -       fgkSSDMountingBlockScrewHoleHeigth
+                                       -       fgkSSDMountingBlockHeight[3]),0.,90.); 
+  TGeoCombiTrans* MountingBlockLowerHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
+  char* MountingBlockLowerHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
+                                       {       "MountingBlockLowerHoleTubeSegCombiTrans0",
+                                               "MountingBlockLowerHoleTubeSegCombiTrans1",
+                                               "MountingBlockLowerHoleTubeSegCombiTrans2",
+                                               "MountingBlockLowerHoleTubeSegCombiTrans3"};
+  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
+    MountingBlockLowerHoleTubeSegCombiTrans[i] =
+                       new TGeoCombiTrans(MountingBlockLowerHoleTubeSegCombiTransName[i],
+                                               0.5*(fgkSSDMountingBlockScrewHoleEdge
+                                       -       2.*fgkSSDMountingBlockScrewHoleRadius[1])
+                                       *       TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
+                                               0.5*(fgkSSDMountingBlockScrewHoleEdge
+                                       -       2.0*fgkSSDMountingBlockScrewHoleRadius[1])
+                                       *       TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
+                                               new TGeoRotation("",90.*i,0.,0.));
+                                       MountingBlockLowerHoleTubeSegCombiTrans[i]->RegisterYourself();
+  }
+  Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
+                                       -       2.*fgkSSDMountingBlockScrewHoleRadius[1];
+  TGeoBBox* MountingBlockLowerHoleBoxShape[2];
+  MountingBlockLowerHoleBoxShape[0] = 
+                       new TGeoBBox("MountingBlockLowerHoleBoxShape0",
+                                               0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
+                                               0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
+                                               0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
+                                       -       fgkSSDMountingBlockScrewHoleHeigth
+                                       -       fgkSSDMountingBlockHeight[3]));
+  MountingBlockLowerHoleBoxShape[1] = 
+                       new TGeoBBox("MountingBlockLowerHoleBoxShape1",
+                                               0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
+                                               0.5*fgkSSDMountingBlockScrewHoleRadius[1],
+                                               0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
+                                       -       fgkSSDMountingBlockScrewHoleHeigth
+                                       -       fgkSSDMountingBlockHeight[3]));
+  TGeoCombiTrans* MountingBlockLowerHoleBoxCombiTrans[MountingBlockHoleTubeSegNumber];
+  char* MountingBlockLowerHoleBoxCombiTransName[MountingBlockHoleTubeSegNumber] = 
+                                       {       "MountingBlockLowerHoleBoxCombiTrans0",
+                                               "MountingBlockLowerHoleBoxCombiTrans1",
+                                               "MountingBlockLowerHoleBoxCombiTrans2",
+                                               "MountingBlockLowerHoleBoxCombiTrans3"};
+  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
+    MountingBlockLowerHoleBoxCombiTrans[i] =
+                       new TGeoCombiTrans(MountingBlockLowerHoleBoxCombiTransName[i],
+                                               0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
+                                       +       fgkSSDMountingBlockScrewHoleRadius[1])
+                                       *       TMath::Cos(90*(i+1)*TMath::DegToRad()),
+                                               0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
+                                       +       fgkSSDMountingBlockScrewHoleRadius[1])
+                                       *       TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
+                                               new TGeoRotation("",90.*i,0.,0.));
+    MountingBlockLowerHoleBoxCombiTrans[i]->RegisterYourself();
+  }
+  MountingBlockScrewHole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
+       "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
+       "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
+       "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
+       "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
+       "MountingBlockLowerHoleBoxShape0+"
+       "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
+       "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
+       "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
+       "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
+  TGeoTranslation* MountingBlockScrewHole1Trans = 
+                       new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
+                                       -       MountingBlockLowerHoleBoxShape[0]->GetDZ()
+                                       -       MountingBlockHoleBoxShape->GetDZ());
+  MountingBlockScrewHole1Trans->RegisterYourself();
+  /* TGeoCompositeShape* MountingBlockHole = */ 
+                       new TGeoCompositeShape("MountingBlockHole",
+       "MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
+  TGeoTranslation* MountingBlockHoleTrans = new TGeoTranslation("MountingBlockHoleTrans",
+                                               0.5*fgkSSDMountingBlockLength[0]
+                                       -       MountingBlockBoxShape[0]->GetDZ(),
+                                               0.0,
+                                               2.*MountingBlockBoxShape[2]->GetDZ()
+                                       -       MountingBlockBoxShape[0]->GetDZ()
+                                       +       fgkSSDMountingBlockHeight[3]
+                                       -       MountingBlockHoleBoxShape->GetDZ());
+  MountingBlockHoleTrans->RegisterYourself();
+  TGeoCompositeShape* MountingBlockShape = new TGeoCompositeShape("MountingBlockShape",
+                       "MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
+                       "MountingBlockTubeShape0:MountingBlockTubeTrans1+"
+                       "MountingBlockTubeShape1:MountingBlockTubeTrans2+"
+                       "MountingBlockTubeShape1:MountingBlockTubeTrans3+"
+                       "HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
+                       "MountingBlockHole:MountingBlockHoleTrans)");
+  TGeoVolume* SSDMountingBlock = new TGeoVolume("SSDMountingBlock",
+                       MountingBlockShape,fgkSSDMountingBlockMedium);
+  return SSDMountingBlock;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
+  TGeoVolume* Ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd" 
+                                                                                                               : "ITSssdLay6Ladd");
+  TGeoVolume* LadderSegment[2];
+  LadderSegment[0] = GetLadderSegment(0);
+  LadderSegment[1] = GetLadderSegment(1);
+  TList* EndLadderSegmentList = GetEndLadderSegment();
+  Double_t BeamAxisTransVector = fgkCarbonFiberJunctionWidth;
+  Int_t SSDLaySensorsNumber = (iLayer==5 ? 
+                                               fgkSSDLay5SensorsNumber : 
+                                               fgkSSDLay6SensorsNumber);
+  for(Int_t i=0; i<SSDLaySensorsNumber; i++) Ladder->AddNode(i%2==0 ? 
+                                               LadderSegment[iLayer==5 ? 0 : 1] : 
+                                               LadderSegment[iLayer==5 ? 1 : 0],
+                                               SSDLaySensorsNumber-i,new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
+                                               BeamAxisTransVector*i,0.));
+  Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(0),1,
+                                               new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
+                                               fgkCarbonFiberJunctionWidth*SSDLaySensorsNumber,0.));
+  Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(1),1,
+                                               new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
+                                               0.,0.,new TGeoRotation("",180.,0.,0.)));
+/////////////////////////////////////////////////////////////////////////////                                          
+/// Placing Ladder Cables
+/////////////////////////////////////////////////////////////////////////////          
+  SetLadderCableCombiTransMatrix(iLayer);
+  Int_t SideCableNumber[2] = {0,0};
+  switch(iLayer){
+       case 5: 
+               SideCableNumber[0] = fgkSSDLay5SensorsNumber/2+1; 
+               SideCableNumber[1] = SideCableNumber[0]-2;
+               break;
+    case 6:
+               SideCableNumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
+               SideCableNumber[1] = SideCableNumber[0]-1;
+               break;
+  }
+  const Double_t* CarbonFiberToModulePosition = 
+                                                        LadderSegmentCombiTransMatrix[1]->GetTranslation();
+  Double_t SSDEndLadderCableLength[4];
+  SSDEndLadderCableLength[0] = CarbonFiberToModulePosition[1]
+                                                        + fgkSSDSensorLength
+                                                        - fgkSSDModuleStiffenerPosition[1]
+                                                        - fgkSSDStiffenerWidth 
+                                                        - fgkSSDFlexWidth[0]
+                                                        + fgkEndLadderCarbonFiberLowerJunctionLength[1];
+  SSDEndLadderCableLength[1] = CarbonFiberToModulePosition[1]
+                                                        + fgkSSDModuleStiffenerPosition[1]
+                                                        + fgkSSDStiffenerWidth
+                                                        + fgkEndLadderCarbonFiberLowerJunctionLength[1];
+  SSDEndLadderCableLength[2] = SSDEndLadderCableLength[1]
+                                                        - fgkEndLadderCarbonFiberLowerJunctionLength[1]
+                                                        + fgkEndLadderCarbonFiberLowerJunctionLength[0];
+  SSDEndLadderCableLength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
+                                                        + CarbonFiberToModulePosition[1]
+                                                        - fgkSSDModuleStiffenerPosition[1]
+                                                        - fgkSSDStiffenerWidth)
+                                                        + fgkEndLadderCarbonFiberLowerJunctionLength[1];
+  TList* LadderCableAssemblyList[4];
+  const Int_t EndLadderCablesNumber = 4;
+  for(Int_t i=0; i<EndLadderCablesNumber; i++){
+         LadderCableAssemblyList[i] = 
+         GetLadderCableAssemblyList(SideCableNumber[i<2?0:1],
+                                                                  SSDEndLadderCableLength[i]);
+         Ladder->AddNode((TGeoVolume*)LadderCableAssemblyList[i]->At(i%2==0?0:1),
+                                                                       i<2?1:2,LadderCableCombiTransMatrix[i]);
+  }
+  return Ladder;
+}                                                                
+////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
+  TGeoVolume* Layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5" 
+                                                                                                          : "ITSssdLayer6");
+  TGeoVolume* Ladder = GetLadder(iLayer);
+  /////////////////////////////////////////////////////
+  // Setting the CombiTransformation to pass ITS center 
+  /////////////////////////////////////////////////////
+  Double_t ITSCenterTransZ = iLayer==5 ? fgkSSDLay5LadderLength
+                           -             fgkLay5CenterITSPosition: 
+                                         fgkSSDLay6LadderLength
+                           -             fgkLay6CenterITSPosition;
+  Double_t ITSSensorYTrans = fgkSSDModuleCoolingBlockToSensor
+                           + 0.5*        fgkCoolingTubeSupportHeight
+                           -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
+                           -             fgkSSDSensorSideSupportHeight[0]: 0.);
+  TGeoRotation* ITSCenterRot[3];
+  ITSCenterRot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
+  ITSCenterRot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
+  ITSCenterRot[2] = new TGeoRotation((*ITSCenterRot[1])*(*ITSCenterRot[0]));
+  TGeoCombiTrans* ITSCenterCombiTrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
+                                        fgkSSDMountingBlockHeight[1]+ITSSensorYTrans,
+                                        fgkEndLadderCarbonFiberLowerJunctionLength[1]
+                                      - ITSCenterTransZ,ITSCenterRot[2]);
+  /////////////////////////////////////////////////////
+  // Setting the Ladder into the Layer 
+  /////////////////////////////////////////////////////
+  Double_t LayLadderAnglePosition = 360./(iLayer==5 ? fgkSSDLay5LadderNumber : 
+                                          fgkSSDLay6LadderNumber);
+  Int_t LayLadderNumber        = iLayer==5 ? fgkSSDLay5LadderNumber : 
+                                             fgkSSDLay6LadderNumber; 
+  Double_t LayRadiusMin        = iLayer==5 ? fgkSSDLay5RadiusMin    : 
+                                             fgkSSDLay6RadiusMin;
+  Double_t LayRadiusMax        = iLayer==5 ? fgkSSDLay5RadiusMax    : 
+                                             fgkSSDLay6RadiusMax;
+  TGeoCombiTrans* LadderCombiTrans[LayLadderNumber];
+  TGeoHMatrix* LadderHMatrix[LayLadderNumber];
+  Double_t LayerRadius = 0.;
+  char LadderCombiTransName[30], LadderRotName[30];
+  for(Int_t i=0; i<LayLadderNumber;i++){
+      sprintf(LadderCombiTransName,"LadderCombiTrans%i",i);
+      sprintf(LadderRotName,"LaddeRot%i",i);
+      switch(iLayer){
+            case 5: 
+                  LayerRadius = (i%2==0 ? LayRadiusMin: LayRadiusMax);
+                  break;
+            case 6:
+                  LayerRadius = (i%2==0 ? LayRadiusMax : LayRadiusMin);
+                  break;
+      }
+      LadderCombiTrans[i] = new TGeoCombiTrans(LadderCombiTransName,
+                            LayerRadius *      TMath::Cos((i+1)
+                          * LayLadderAnglePosition*TMath::DegToRad()),
+                            LayerRadius *      TMath::Sin((i+1)
+                          * LayLadderAnglePosition*TMath::DegToRad()),0.,
+                            new TGeoRotation(LadderRotName,(i+1)
+                          * LayLadderAnglePosition-90,0.,0.));
+    LadderHMatrix[i] = new TGeoHMatrix((*LadderCombiTrans[i])
+                          * (*ITSCenterCombiTrans));
+    Layer->AddNode(Ladder,i+1,LadderHMatrix[i]);          
+  }   
+  return Layer;
+}
+////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
+////////////////////////////////////////////////////////////////////////////////
+// Insert the layer 5 in the mother volume. 
+////////////////////////////////////////////////////////////////////////////////
+       if(! moth){
+               cout << "Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!"<< endl;
+               return;
+       }
+       fMotherVol = moth;
+       moth->AddNode(GetLayer(5),1,0);
+}
+////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
+////////////////////////////////////////////////////////////////////////////////
+// Insert the layer 6 in the mother volume. 
+////////////////////////////////////////////////////////////////////////////////
+       if(! moth){
+               cout << "Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!"<< endl;
+               return;
+       }
+       fMotherVol = moth;
+       moth->AddNode(GetLayer(6),1,0);
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[], 
+                                                       Double_t* width, Double_t height, char* shapename){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  const Int_t TransVectNumber = 2;
+  TVector3* Vertex[VertexNumber];
+  TVector3* TransVector[2];
+  for(Int_t i=0; i<TransVectNumber; i++) 
+                                                                       TransVector[i] = new TVector3(0.,width[i]);
+////////////////////////////////////////////////////////////////////////////////
+  //Setting the vertices
+////////////////////////////////////////////////////////////////////////////////
+  Vertex[0] = new TVector3(*vertexpos[0]);
+  Vertex[1] = new TVector3(*vertexpos[1]);
+  Vertex[2] = new TVector3(*Vertex[1]+*TransVector[1]);
+  Vertex[3] = new TVector3(*Vertex[0]+*TransVector[0]);
+  TGeoArb8* TrapezoidShape = new TGeoArb8(shapename,0.5*height);
+  for(Int_t i=0; i<2*VertexNumber; i++) 
+       TrapezoidShape->SetVertex(i,Vertex[(i<VertexNumber ? i : i-VertexNumber)]->X(),
+                                                               Vertex[(i<VertexNumber ? i : i-VertexNumber)]->Y()); 
+  return TrapezoidShape;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, 
+                                                                       Double_t height, char* shapename, Int_t isign){
+  const Int_t VertexNumber = 8;
+  const Int_t TransVectNumber = 2;
+  TVector3* Vertex[VertexNumber];
+  TVector3* TransVector[2];
+  for(Int_t i=0; i<TransVectNumber; i++) TransVector[i] = new TVector3(0.,width[i]);
+////////////////////////////////////////////////////////////////////////////////
+  //Setting the vertices for TGeoArb8
+////////////////////////////////////////////////////////////////////////////////
+  Vertex[0] = new TVector3(*vertexpos[0]);
+  Vertex[1] = new TVector3(*vertexpos[1]);
+  Vertex[2] = new TVector3(*Vertex[1]+isign*(*TransVector[0]));
+  Vertex[3] = new TVector3(*Vertex[0]+isign*(*TransVector[0]));
+  Vertex[4] = new TVector3(*vertexpos[2]);
+  Vertex[5] = new TVector3(*vertexpos[3]);
+  Vertex[6] = new TVector3(*Vertex[5]+isign*(*TransVector[1]));
+  Vertex[7] = new TVector3(*Vertex[4]+isign*(*TransVector[1]));
+////////////////////////////////////////////////////////////////////////////////
+  TGeoArb8* ArbShape = new TGeoArb8(shapename,0.5*height);
+  for(Int_t i = 0; i<VertexNumber;i++) 
+                                                       ArbShape->SetVertex(i,Vertex[i]->X(),Vertex[i]->Y());
+  return ArbShape;
+} 
+////////////////////////////////////////////////////////////////////////////////
+TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[], 
+                                                                                         Double_t height, char* shapename){
+////////////////////////////////////////////////////////////////////////////////
+  const Int_t VertexNumber = 4;
+  TVector3* Vertex[VertexNumber];
+//////////////////////////////////////
+  //Setting the vertices for TGeoArb8
+  ////////////////////////////////////
+  for(Int_t i = 0; i<VertexNumber; i++)  
+  Vertex[i] = new TVector3(i!=VertexNumber-1?*vertexpos[i]:*Vertex[VertexNumber-1-i]);
+  TGeoArb8* TriangleShape = new TGeoArb8(shapename,0.5*height);
+  for(Int_t i = 0; i<2*VertexNumber; i++) 
+       TriangleShape->SetVertex(i,Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
+                                                          Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
+  return TriangleShape;
+}
+////////////////////////////////////////////////////////////////////////////////
+TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* Vector,Double_t* Param){
+////////////////////////////////////////////////////////////////////////////////
+  TVector3* n = new TVector3(Param[0],Param[1],Param[2]);
+  Double_t D = ((*Vector)*(*n)+Param[3])/n->Mag2();
+  TVector3* ReflectedVector = new TVector3(*Vector-2*D*(*n));
+  return ReflectedVector;
+}
+////////////////////////////////////////////////////////////////////////////////
+TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
+                                                       Double_t dx,
+                                                       Double_t dy,
+                                                       Double_t dz) const{
+  TGeoCombiTrans* CombiTrans = new TGeoCombiTrans(*ct);
+  // Add a dx,dy,dz translation to the initial TGeoCombiTrans
+  const Double_t *vect = CombiTrans->GetTranslation();
+  Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
+  CombiTrans->SetTranslation(newVect);
+  return CombiTrans;
+}
+////////////////////////////////////////////////////////////////////////////////
+//To be interfaced with AliRoot Materials file
+////////////////////////////////////////////////////////////////////////////////
+TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
+  char ch[30];
+  sprintf(ch, "ITS_%s",mediumName);
+  TGeoMedium* medium =  gGeoManager->GetMedium(ch);
+  if (! medium)
+    printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
+  return medium;
+}
+////////////////////////////////////////////////////////////////////////////////
+//To be interfaced with AliRoot Materials file
+////////////////////////////////////////////////////////////////////////////////
+/*void AliITSv11GeometrySSD::CreateMaterials(){
+///////////////////////////////////
+// This part has to be modified
+///////////////////////////////////
+//  Float_t ifield =  2.000;
+//  Float_t fieldm = 10.000;
+//    Int_t   ifield = gAlice->Field()->Integ();
+//    Float_t fieldm = gAlice->Field()->Max();
+  ///////////////////////////////////
+  // Silicon for Sensor
+  /////////////////////////////////// 
+  Int_t SINumber = 0;
+  TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
+  TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
+  fgkSSDSensorMedium = Silicon;
+  ///////////////////////////////////
+  // Silicon Mixture for Sensor
+  /////////////////////////////////// 
+  Int_t SiMixtureNumber = 1;
+  TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
+  TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
+  fgkSSDChipMedium = SiliconMixture;
+  ///////////////////////////////////
+  // Stiffener Components Materials
+  /////////////////////////////////// 
+  Int_t K1100Number = 2;
+  TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
+  TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
+  fgkSSDStiffenerMedium = K1100;
+  ///////////////////////////  
+  // Stiffener Connectors 
+  ///////////////////////////  
+  Int_t SnMaterialNumber = 3;
+  TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
+  TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
+                                                SnMaterial);
+  fgkSSDStiffenerConnectorMedium = SnMedium;
+  ////////////////////////////////  
+  // Stiffener 0603-1812 Capacitor
+  ////////////////////////////////  
+  Int_t Al2O3Number = 4;
+  TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
+  TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
+                                                Al2O3Number,
+                                                Al2O3Material);
+  fgkSSDStiffener0603CapacitorMedium = Al2O3Medium;
+  fgkSSDStiffener1812CapacitorMedium = Al2O3Medium;
+  ///////////////////////////  
+  // Stiffener Hybrid Wire 
+  ///////////////////////////  
+  Int_t CuHybridWireNumber = 5;
+  TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
+  TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
+                                                CuHybridWireNumber,
+                                                CuHybridWireMaterial);
+  fgkSSDStiffenerHybridWireMedium = CuHybridWireMedium;
+  ///////////////////////////  
+  // Al for Cooling Block
+  ///////////////////////////  
+  Int_t AlCoolBlockNumber = 6;
+  TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
+  TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
+                                                AlCoolBlockNumber,
+                                                AlCoolBlockMaterial);
+  fgkSSDAlCoolBlockMedium = AlCoolBlockMedium;
+  //////////////////////////////////////////////////////  
+  // Kapton and Al for Chip Cable Flex and Ladder Cables
+  //////////////////////////////////////////////////////  
+  Int_t KaptonBlockNumber = 7;
+  TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
+  TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
+                                                KaptonBlockNumber,
+                                                KaptonMaterial);
+  Int_t AlTraceBlockNumber = 8;
+  TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
+  TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
+                                                AlTraceBlockNumber,
+                                                AlTraceMaterial);
+  fgkSSDKaptonChipCableMedium = KaptonMedium;
+  fgkSSDAlTraceChipCableMedium = AlTraceMedium;
+  fgkSSDKaptonFlexMedium = KaptonMedium;
+  fgkSSDAlTraceFlexMedium = AlTraceMedium;
+  fgkSSDKaptonLadderCableMedium = KaptonMedium;
+  fgkSSDAlTraceLadderCableMedium = AlTraceMedium;
+  /////////////////////////////////////////////////////////////////  
+  // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
+  //////////////////////////////////////////////////////////////////  
+  Int_t M55JNumber = 9;
+  TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
+  TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
+                                           M55JMaterial);
+  fgkSSDCarbonFiberMedium = M55JMedium;
+  fgkSSDMountingBlockMedium = M55JMedium;
+  /////////////////////////////////////////////////////////////////  
+  // G10 for Detector Leg, TubeHolder
+  //////////////////////////////////////////////////////////////////  
+  Int_t G10Number = 10;
+  TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
+  TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
+                                           G10Material);
+  fgkSSDTubeHolderMedium = G10Medium;
+  fgkSSDSensorSupportMedium = G10Medium;
+  /////////////////////////////////////////////////////////////////  
+  // Water and Phynox for Cooling Tube
+  //////////////////////////////////////////////////////////////////  
+  Int_t WaterNumber = 11;
+  TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
+  TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
+                                           WaterMaterial);
+  fgkSSDCoolingTubeWater = WaterMedium;
+  Int_t PhynoxNumber = 12;
+  TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
+  TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
+                                           PhynoxMaterial);
+  fgkSSDCoolingTubePhynox = PhynoxMedium;
+}
+*/
+void AliITSv11GeometrySSD::CreateMaterials(){
+///////////////////////////////////
+// This part has to be modified
+///////////////////////////////////
+  ///////////////////////////////////
+  // Silicon for Sensor
+  /////////////////////////////////// 
+  fgkSSDSensorMedium = GetMedium("Si");
+  ///////////////////////////////////
+  // Silicon Mixture for Sensor
+  /////////////////////////////////// 
+  fgkSSDChipMedium = GetMedium("SPD SI CHIP$");
+  fgkSSDChipGlueMedium = GetMedium("EPOXY$");
+  ///////////////////////////////////
+  // Stiffener Components Materials
+  /////////////////////////////////// 
+  fgkSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
+  ///////////////////////////  
+  // Stiffener Connectors 
+  ///////////////////////////  
+  fgkSSDStiffenerConnectorMedium = GetMedium("COPPER");
+  ////////////////////////////////  
+  // Stiffener 0603-1812 Capacitor
+  ////////////////////////////////  
+  fgkSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
+  fgkSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
+  ///////////////////////////  
+  // Stiffener Hybrid Wire 
+  ///////////////////////////  
+  fgkSSDStiffenerHybridWireMedium = GetMedium("COPPER");
+  ///////////////////////////  
+  // Al for Cooling Block
+  ///////////////////////////  
+  fgkSSDAlCoolBlockMedium = GetMedium("ITSal");
+  //////////////////////////////////////////////////////  
+  // Kapton and Al for Chip Cable Flex and Ladder Cables
+  //////////////////////////////////////////////////////  
+  fgkSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
+  fgkSSDAlTraceChipCableMedium = GetMedium("ITSal");
+  fgkSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
+  fgkSSDAlTraceFlexMedium = GetMedium("ITSal");
+  fgkSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
+  fgkSSDAlTraceLadderCableMedium = GetMedium("ITSal");
+  /////////////////////////////////////////////////////////////////  
+  // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
+  //////////////////////////////////////////////////////////////////  
+  fgkSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
+  /////////////////////////////////////////////////////////////////  
+  // G10 for Detector Leg, TubeHolder
+  //////////////////////////////////////////////////////////////////  
+  fgkSSDTubeHolderMedium = GetMedium("G10FR4$");
+  fgkSSDSensorSupportMedium = GetMedium("G10FR4$");
+  fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
+  fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
+  /////////////////////////////////////////////////////////////////  
+  // Water and Phynox for Cooling Tube
+  //////////////////////////////////////////////////////////////////  
+  fgkSSDCoolingTubeWater = GetMedium("WATER");
+  fgkSSDCoolingTubePhynox = GetMedium("INOX$");
+}
+/////////////////////////////////////////////////////////////////////
diff --git a/ITS/AliITSv11GeometrySSD.h b/ITS/AliITSv11GeometrySSD.h
new file mode 100644 (file)
index 0000000..07c1136
--- /dev/null
@@ -0,0 +1,326 @@
+//*************************************************************************
+// class AliITSv11GeometrySSD
+// Enrico Cattaruzza                                     ecattar@ts.infn.it
+//*************************************************************************
+#ifndef ALIITSV11GEOMETRYSSD_H
+#define ALIITSV11GEOMETRYSSD_H
+class TGeoVolume;
+class TGeoCombiTrans;
+class TGeoMedium;
+class TGeoCompositeShape;
+class TVector3;
+class TGeoArb8;
+class TList;
+class TGeoTube;
+class TGeoHMatrix;
+class AliITSv11GeometrySSD{
+public:
+  AliITSv11GeometrySSD();
+  virtual ~AliITSv11GeometrySSD(){};
+  /////////////////////////////////////////////////////////////////////////
+  // Public methods
+  /////////////////////////////////////////////////////////////////////////
+  TGeoMedium *GetMedium(char*); // to be interfaced with AliRoot
+  const char*   GetSensitiveVolumeName() const {return fgkSSDSensitiveVolName;};
+  TGeoVolume* GetSSDSensorSupportShape(Double_t,Double_t,Double_t,Double_t*);
+  TGeoVolume* GetSSDSensorSupport(Int_t, Int_t);
+  TGeoVolume* GetSSDSensorSupportAssembly(Int_t);
+  TGeoVolume* GetSSDSensor();
+  TGeoVolume* GetSSDChipAssembly();
+  TGeoVolume* GetSSDChipCables(Double_t,char*);
+  TGeoVolume* GetSSDChipCablesAssembly(Double_t);
+  TGeoVolume* GetSSDStiffenerAssembly();
+  TGeoVolume* GetSSDFlex(Double_t,Double_t);
+  TGeoVolume* GetSSDEndFlex(Double_t,Double_t);
+  TGeoVolume* GetSSDFlexAssembly();
+  TGeoVolume* GetSSDCoolingBlock();
+  TGeoVolume* GetSSDCoolingBlockAssembly();
+  TGeoVolume* GetSSDModule(Int_t);
+  TGeoVolume* GetCarbonFiberJunction(Double_t);
+  TGeoVolume* GetCarbonFiberJunctionAssembly();
+  TList* GetLadderCableSegment(Double_t);
+  TGeoVolume* GetLadderCable(Int_t n,Double_t);
+  TGeoVolume* GetLadderCableAssembly(Int_t n,Double_t);
+  TList* GetLadderCableAssemblyList(Int_t n,Double_t);
+  TList* GetEndLadderCarbonFiberJunctionAssembly();
+  TGeoVolume* GetCarbonFiberSupport();
+  TGeoVolume* GetCarbonFiberLowerSupport(Int_t i=0, Bool_t EndLadder = false);
+  TGeoVolume* GetCarbonFiberAssemblySupport();
+  TGeoVolume* GetCoolingTubeSupport();
+  TGeoVolume* GetCoolingTubeSupportAssembly();
+  TGeoVolume* GetCoolingTube();
+  TGeoVolume* GetCoolingTubeAssembly();
+  TGeoVolume* GetLadderSegment(Int_t);
+  TList* GetEndLadderSegment();
+  TGeoVolume* GetSSDMountingBlock();
+  TGeoVolume* GetLadder(Int_t);
+  TGeoVolume* GetLayer(Int_t);
+  void Layer5(TGeoVolume*);
+  void Layer6(TGeoVolume*);
+  /////////////////////////////////////////////////////////////////////////
+  //Auxiliary methods for shapes building
+  /////////////////////////////////////////////////////////////////////////
+  TVector3* GetReflection(TVector3*,Double_t*);
+  TGeoArb8* GetArbShape(TVector3* [],Double_t*,Double_t,char*,Int_t isign = 1);
+  TGeoArb8* GetTriangleShape(TVector3* [],Double_t,char*);
+  TGeoArb8* GetTrapezoidShape(TVector3* [],Double_t*,Double_t,char*);
+  TGeoCombiTrans* AddTranslationToCombiTrans(TGeoCombiTrans*,Double_t,
+                                                        Double_t,Double_t) const;
+  /////////////////////////////////////////////////////////////////////////
+  //Auxiliary methods for material building
+  /////////////////////////////////////////////////////////////////////////
+  TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName);
+  void CreateMaterials();
+private:
+  /////////////////////////////////////////////////////////////////////////
+  // Layer5 (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDLay5LadderLength;
+  static const Int_t fgkSSDLay5SensorsNumber;
+  static const Int_t fgkSSDLay5LadderNumber;
+  static const Double_t fgkSSDLay5RadiusMin;
+  static const Double_t fgkSSDLay5RadiusMax;
+  static const Double_t fgkLay5CenterITSPosition;
+  /////////////////////////////////////////////////////////////////////////
+  // Layer6 (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDLay6LadderLength; //It is not used explicitely in the simulation
+  static const Int_t fgkSSDLay6SensorsNumber;
+  static const Int_t fgkSSDLay6LadderNumber;
+  static const Double_t fgkSSDLay6RadiusMin;
+  static const Double_t fgkSSDLay6RadiusMax;
+  static const Double_t fgkLay6CenterITSPosition;
+  /////////////////////////////////////////////////////////////////////////
+  // SSD Chips and Hybrid
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkSSDChipNumber;
+  static const Double_t fgkSSDChipLength; 
+  static const Double_t fgkSSDChipWidth;
+  static const Double_t fgkSSDChipHeight;
+  static const Double_t fgkSSDChipSeparationLength;
+  static const Double_t fgkSSDChipGlueLength; 
+  static const Double_t fgkSSDChipGlueWidth; 
+  static const Double_t fgkSSDChipGlueHeight; 
+  TGeoMedium* fgkSSDChipMedium;
+  TGeoMedium* fgkSSDChipGlueMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // Stiffener
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDStiffenerLength;
+  static const Double_t fgkSSDStiffenerWidth;
+  static const Double_t fgkSSDStiffenerHeight;
+  static const Double_t fgkSSDStiffenerToChipDist;
+  static const Double_t fgkSSDCapacitor0603Length;
+  static const Double_t fgkSSDCapacitor0603Width;
+  static const Double_t fgkSSDCapacitor0603Height;
+  static const Double_t fgkSSDCapacitor1812Length;
+  static const Double_t fgkSSDCapacitor1812Width;
+  static const Double_t fgkSSDCapacitor1812Height;
+  static const Double_t fgkSSDWireLength;
+  static const Double_t fgkSSDWireRadius;
+  static const Double_t fgkSSDConnectorPosition[2];
+  static const Double_t fgkSSDConnectorSeparation;
+  static const Double_t fgkSSDConnectorLength;
+  static const Double_t fgkSSDConnectorWidth;
+  static const Double_t fgkSSDConnectorHeight;
+  TGeoMedium* fgkSSDStiffenerMedium;
+  TGeoMedium* fgkSSDStiffenerConnectorMedium;
+  TGeoMedium* fgkSSDStiffener0603CapacitorMedium;
+  TGeoMedium* fgkSSDStiffener1812CapacitorMedium;
+  TGeoMedium* fgkSSDStiffenerHybridWireMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // Flex
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDFlexFullLength;
+  static const Double_t fgkSSDFlexLength[4];
+  static const Double_t fgkSSDFlexWidth[2];
+  static const Double_t fgkSSDFlexHeight[2];
+  static const Double_t fgkSSDFlexAngle;
+  static const Double_t fgkSSDFlexHoleLength;
+  static const Double_t fgkSSDFlexHoleWidth;
+  static const Double_t fgkSSDEndFlexCompLength[6];
+  static const Double_t fgkSSDEndFlexCompWidth[3];
+  TGeoMedium* fgkSSDKaptonFlexMedium;
+  TGeoMedium* fgkSSDAlTraceFlexMedium;
+  /////////////////////////////////////////////////////////////////////////////////
+  // SSD Ladder Cable 
+  /////////////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDEndLadderCableLength;
+  static const Double_t fgkSSDLadderCableWidth;
+  TGeoMedium* fgkSSDAlTraceLadderCableMedium;
+  TGeoMedium* fgkSSDKaptonLadderCableMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // SSD Module
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDModuleStiffenerPosition[2];
+  static const Double_t fgkSSDModuleSensorSupportDistance;
+  static const Double_t fgkSSDModuleCoolingBlockToSensor;
+  static const Int_t fgkSSDModuleCombiTransNumber = 7;
+  void SetSSDModuleCombiTransMatrix(Double_t);
+  TGeoCombiTrans *SSDModuleCombiTransMatrix[fgkSSDModuleCombiTransNumber];
+  /////////////////////////////////////////////////////////////////////////
+  // Chip Cables
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDChipCablesLength[2];
+  static const Double_t fgkSSDChipCablesHeight[4];
+  static const Double_t fgkSSDChipCablesWidth[3];
+  TGeoMedium* fgkSSDKaptonChipCableMedium;
+  TGeoMedium* fgkSSDAlTraceChipCableMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // Cooling Block
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDCoolingBlockLength;
+  static const Double_t fgkSSDCoolingBlockWidth;
+  static const Double_t fgkSSDCoolingBlockHeight[3];
+  static const Double_t fgkSSDCoolingBlockHoleRadius[2];
+  static const Double_t fgkSSDCoolingBlockHoleLength[2];
+  static const Double_t fgkSSDCoolingBlockHoleCenter;
+  static const Double_t fgkSSDCoolingBlockHoleHeight;
+  TGeoMedium* fgkSSDAlCoolBlockMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // SSD Sensor 
+  /////////////////////////////////////////////////////////////////////////
+  static const char* fgkSSDSensitiveVolName;
+  static const Double_t fgkSSDSensorLength;
+  static const Double_t fgkSSDSensorHeight;
+  static const Double_t fgkSSDSensorWidth;
+  static const Double_t fgkSSDSensorOverlap;
+  static const Double_t fgkSSDSensorInsensitiveLength;
+  static const Double_t fgkSSDSensorInsensitiveWidth;
+  TGeoMedium* fgkSSDSensorMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // SSD Sensor Support 
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkSSDSensorSupportCombiTransNumber = 3;
+  static const Double_t fgkSSDSensorSideSupportLength;
+  static const Double_t fgkSSDSensorSideSupportWidth;
+  static const Double_t fgkSSDSensorSideSupportHeight[2];
+  static const Double_t fgkSSDSensorSideSupportThickness[2];
+  static const Double_t fgkSSDSensorSideSupportPosition;
+  static const Double_t fgkSSDSensorCenterSupportLength;
+  static const Double_t fgkSSDSensorCenterSupportWidth;
+  static const Double_t fgkSSDSensorCenterSupportHeight[2];
+  static const Double_t fgkSSDSensorCenterSupportThickness[2];
+  static const Double_t fgkSSDSensorCenterSupportPosition;
+  void SetSSDSensorSupportCombiTransMatrix();
+  TGeoCombiTrans *SSDSensorSupportCombiTransMatrix[fgkSSDSensorSupportCombiTransNumber];
+  TGeoMedium* fgkSSDSensorSupportMedium;
+  /////////////////////////////////////////////////////////////////////////
+  //Parameters for Carbon Fiber 
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkCarbonFiberAssemblyCombiTransNumber = 3;
+  static const Double_t fgkCarbonFiberTriangleLength;
+  static const Double_t fgkCarbonFiberTriangleAngle;
+  static const Double_t fgkCarbonFiberSupportTopEdgeDist[2];
+  static const Double_t fgkCarbonFiberSupportEdgeLength;
+  static const Double_t fgkCarbonFiberSupportWidth;
+  static const Double_t fgkCarbonFiberSupportXAxisLength;
+  static const Double_t fgkCarbonFiberSupportYAxisLength;
+  void SetCarbonFiberAssemblyCombiTransMatrix();
+  TGeoCombiTrans *CarbonFiberAssemblyCombiTransMatrix[fgkCarbonFiberAssemblyCombiTransNumber];
+  TGeoMedium* fgkSSDCarbonFiberMedium;
+  //////////////////////////////////////////////////////////////////////////////
+  // Carbon Fiber Junction Parameters
+  //////////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkCarbonFiberJunctionCombiTransNumber = 3;
+  static const Double_t fgkCarbonFiberJunctionLength;
+  static const Double_t fgkCarbonFiberJunctionWidth;
+  static const Double_t fgkCarbonFiberJunctionEdge[2];
+  static const Double_t fgkCarbonFiberJunctionAngle[2];
+  static const Double_t fgkCarbonFiberJunctionToSensorSupport;
+  void SetCarbonFiberJunctionCombiTransMatrix();
+  TGeoCombiTrans *CarbonFiberJunctionCombiTransMatrix[fgkCarbonFiberJunctionCombiTransNumber];
+  /////////////////////////////////////////////////////////////////////////
+  //Parameters for Carbon Fiber Lower Support (lengths are in mm)
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkCarbonFiberLowerSupportWidth;
+  static const Double_t fgkCarbonFiberLowerSupportLowerLenght;
+  static const Double_t fgkCarbonFiberLowerSupportHeight;
+  static const Double_t fgkCarbonFiberLowerSupportTransverseWidth;
+  static const Double_t fgkCarbonFiberLowerSupportVolumeSeparation;
+  static const Double_t fgkCarbonFiberLowerSupportVolumePosition[2];
+  /////////////////////////////////////////////////////////////////////////
+  // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkEndLadderCarbonFiberJunctionCombiTransNumber = 3;
+  static const Double_t fgkEndLadderCarbonFiberLowerJunctionLength[2]; 
+  static const Double_t fgkEndLadderCarbonFiberUpperJunctionLength[2]; 
+  static const Double_t fgkEndLadderMountingBlockPosition[2];
+  void SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t);
+  TGeoCombiTrans *EndLadderCarbonFiberJunctionCombiTransMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
+  /////////////////////////////////////////////////////////////////////////
+  // Cooling Tube Support (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkCoolingTubeSupportCombiTransNumber = 2;
+  static const Double_t fgkCoolingTubeSupportRmax;
+  static const Double_t fgkCoolingTubeSupportRmin;
+  static const Double_t fgkCoolingTubeSupportLength;
+  static const Double_t fgkCoolingTubeSupportHeight;
+  static const Double_t fgkCoolingTubeSupportWidth;
+  static const Double_t fgkCoolingTubeSupportSeparation;
+  static const Double_t fgkCoolingTubeSupportToCarbonFiber;
+  void SetCoolingTubeSupportCombiTransMatrix();
+  TGeoCombiTrans *CoolingTubeSupportCombiTransMatrix[fgkCoolingTubeSupportCombiTransNumber];
+  TGeoMedium* fgkSSDTubeHolderMedium;
+  /////////////////////////////////////////////////////////////////////////////////
+  // Cooling Tube (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////////////
+  static const Int_t    fgkCoolingTubeCombiTransNumber = 2;
+  static const Double_t fgkCoolingTubeRmax;
+  static const Double_t fgkCoolingTubeRmin;
+  static const Double_t fgkCoolingTubeLength;
+  static const Double_t fgkCoolingTubeSeparation;
+  void SetCoolingTubeCombiTransMatrix();
+  TGeoCombiTrans *CoolingTubeTransMatrix[fgkCoolingTubeCombiTransNumber];
+  TGeoMedium* fgkSSDCoolingTubeWater;
+  TGeoMedium* fgkSSDCoolingTubePhynox;
+  /////////////////////////////////////////////////////////////////////////
+  // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
+  /////////////////////////////////////////////////////////////////////////
+  static const Double_t fgkSSDMountingBlockLength[3];  
+  static const Double_t fgkSSDMountingBlockHeight[4];
+  static const Double_t fgkSSDMountingBlockWidth;
+  static const Double_t fgkSSDMountingBlockHoleTrapezoidAngle;
+  static const Double_t fgkSSDMountingBlockHoleTrapezoidHeight;
+  static const Double_t fgkSSDMountingBlockHoleTrapezoidUpBasis;
+  static const Double_t fgkSSDMountingBlockHoleTubeLength[2];
+  static const Double_t fgkSSDMountingBlockHoleTubeWidth[2]; 
+  static const Double_t fgkSSDMountingBlockHoleRadius;
+  static const Double_t fgkSSDMountingBlockScrewHoleEdge;
+  static const Double_t fgkSSDMountingBlockScrewHoleHeigth;
+  static const Double_t fgkSSDMountingBlockScrewHoleRadius[2];
+  TGeoMedium* fgkSSDMountingBlockMedium;
+  /////////////////////////////////////////////////////////////////////////
+  // LadderSegment 
+  /////////////////////////////////////////////////////////////////////////
+  static const Int_t fgkLadderSegmentCombiTransNumber = 5;
+  void SetLadderSegmentCombiTransMatrix();
+  TGeoCombiTrans *LadderSegmentCombiTransMatrix[fgkLadderSegmentCombiTransNumber];
+  static const Int_t fgkEndLadderSegmentCombiTransNumber = 4;
+  void SetEndLadderSegmentCombiTransMatrix(Int_t);
+  TGeoCombiTrans *EndLadderSegmentCombiTransMatrix[fgkEndLadderSegmentCombiTransNumber];
+  /////////////////////////////////////////////////////////////////////////
+  // LadderCables 
+  /////////////////////////////////////////////////////////////////////////
+  void SetLadderCableCombiTransMatrix(Int_t);
+  TGeoCombiTrans *LadderCableCombiTransMatrix[4];
+  /////////////////////////////////////////////////////////////////////////
+  // Mother Volume 
+  /////////////////////////////////////////////////////////////////////////
+  TGeoVolume *fMotherVol;  
+  TGeoVolume* GetMotherVolume() const { return fMotherVol;};
+  /////////////////////////////////////////////////////////////////////////
+  // Color Display 
+  /////////////////////////////////////////////////////////////////////////
+  Int_t fColorCarbonFiber;   
+  Int_t fColorRyton;         
+  Int_t fColorPhynox;        
+  Int_t fColorSilicon;       
+  Int_t fColorAl;   
+  Int_t fColorKapton;         
+  Int_t fColorPolyhamide;    
+  Int_t fColorStiffener;
+  Int_t fColorEpoxy;
+};
+#endif
+
index 1477c66..c750011 100644 (file)
@@ -29,7 +29,7 @@
 #pragma link C++ class  AliITSv11GeometrySupport+;
 #pragma link C++ class  AliITSv11GeometrySPD+;
 #pragma link C++ class  AliITSv11GeometrySDD+;
-//#pragma link C++ class  AliITSv11GeometrySSD+;
+#pragma link C++ class  AliITSv11GeometrySSD+;
 #pragma link C++ class  AliITShit+;
 // Standard ITS detector class initilizers
 #pragma link C++ class  AliITSmodule+;
index 4ec3c4b..c7fdee1 100644 (file)
@@ -32,6 +32,7 @@ SRCS =        AliITS.cxx \
                AliITSv11GeomCableRound.cxx \
                AliITSv11GeometrySDD.cxx \
                 AliITSv11GeometrySPD.cxx \
+                AliITSv11GeometrySSD.cxx \
                 AliITSv11GeometrySupport.cxx 
 
 HDRS:=  $(SRCS:.cxx=.h)