Introduction of the new SSD geometry in simulation (AliITSv11Hybrid) and suppression...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Jun 2007 10:17:25 +0000 (10:17 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Jun 2007 10:17:25 +0000 (10:17 +0000)
ITS/AliITSInitGeometry.cxx
ITS/AliITSv11GeometrySDD.cxx
ITS/AliITSv11GeometrySDD.h
ITS/AliITSv11GeometrySSD.cxx
ITS/AliITSv11GeometrySSD.h
ITS/AliITSv11Hybrid.cxx
ITS/AliITSv11Hybrid.h

index 1ccedf7..4edc0c2 100644 (file)
@@ -58,7 +58,7 @@ ClassImp(AliITSInitGeometry)
 
 const Bool_t AliITSInitGeometry::fgkOldSPDbarrel = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldSDDbarrel = kFALSE;
-const Bool_t AliITSInitGeometry::fgkOldSSDbarrel = kTRUE;
+const Bool_t AliITSInitGeometry::fgkOldSSDbarrel = kFALSE;
 const Bool_t AliITSInitGeometry::fgkOldSDDcone   = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldSSDcone   = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldSPDshield = kTRUE;
@@ -794,14 +794,23 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
     pathSDDsens1 = "%sITSD_1/IT34_1/I004_%d/I302_%d/ITS3_%d";
     pathSDDsens2 = "%sITSD_1/IT34_1/I005_%d/I402_%d/ITS4_%d";
   }
-  
+
+  char *pathSSDsens1, *pathSSDsens2;
+  if (SSDIsTGeoNative()) {
+    pathSSDsens1 = "%sITSssdLayer5_1/ITSssdLay5Ladd_%d/ITSsddSensor5_%d/ITSsddSensitivL5_1";
+    pathSSDsens2 = "%sITSssdLayer6_1/ITSssdLay6Ladd_%d/ITSsddSensor6_%d/ITSsddSensitivL6_1";
+  } else{
+    pathSSDsens1 = "%sITSD_1/IT56_1/I565_%d/I562_%d/ITS5_%d";
+    pathSSDsens2 = "%sITSD_1/IT56_1/I569_%d/I566_%d/ITS6_%d";
+  }
+
   const TString kNames[klayers] = {
     "%sITSD_1/IT12_1/I12B_%d/I10B_%d/I107_%d/I101_1/ITS1_1", // lay=1
     "%sITSD_1/IT12_1/I12B_%d/I20B_%d/I1D7_%d/I1D1_1/ITS2_1", // lay=2
     pathSDDsens1, // lay=3
     pathSDDsens2, // lay=4
-    "%sITSD_1/IT56_1/I565_%d/I562_%d/ITS5_%d", // lay=5
-    "%sITSD_1/IT56_1/I569_%d/I566_%d/ITS6_%d"};// Lay=6
+    pathSSDsens1, // lay=5
+    pathSSDsens2};// Lay=6
   
   Int_t mod,nmods=0, lay, lad, det, cpn0, cpn1, cpn2;
   Double_t tran[3]={0.,0.,0.}, rot[10]={9*0.0,1.0};
@@ -825,14 +834,18 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
     geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
     RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
 
-
-
     if (SDDIsTGeoNative())
       if (kIdet[lay-1]==kSDD) {
        cpn0 = lad-1;
        cpn1 = det-1;
        cpn2 = 1;
       }
+    if (SSDIsTGeoNative())
+      if (kIdet[lay-1]==kSSD) {
+       cpn0 = lad-1;
+       cpn1 = det-1;
+       cpn2 = 1;
+      }
 
     path.Form(kNames[lay-1].Data(),
              kPathbase.Data(),cpn0,cpn1,cpn2);
@@ -2156,8 +2169,13 @@ void AliITSInitGeometry::DecodeDetectorv11Hybrid(Int_t &mod,Int_t layer,Int_t cp
     }
   } break;
   case 5: case 6:{
-    lad = cpn0;
-    det = cpn1;
+    if (SSDIsTGeoNative()) {
+      lad = cpn0+1;
+      det = cpn1+1;
+    } else {
+      lad = cpn0;
+      det = cpn1;
+    }
   } break;
   default:{
   } break;
index 405fb06..0462d2c 100755 (executable)
@@ -42,6 +42,7 @@
 #include <TGeoCompositeShape.h>
 #include <TGeoMatrix.h>
 #include <TGeoNode.h>
+#include <TGeoPcon.h>
 
 #include "AliITSgeom.h"
 #include "AliITSgeomSDD.h"
@@ -105,8 +106,8 @@ const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth       =  6 *fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX        = 10 *fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY        =  6.5 *fgkmm;
 
-const Double_t AliITSv11GeometrySDD::fgkLay3Rmin           = 145.*fgkmm;      // not min! Rmin virtual tube
-const Double_t AliITSv11GeometrySDD::fgkLay3Rmax           = 205.*fgkmm;      // not min! Rmax virtual tube
+const Double_t AliITSv11GeometrySDD::fgkLay3Rmin           = 145.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLay3Rmax           = 200.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLay3Length         = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
 const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength   = 524.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm;
@@ -116,8 +117,8 @@ const Int_t    AliITSv11GeometrySDD::fgkLay3Ndet           =  6;
 const Int_t    AliITSv11GeometrySDD::fgkLay3Nladd          = 14;
 const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH  =  7.5*fgkmm;
 
-const Double_t AliITSv11GeometrySDD::fgkLay4Rmin           = 220.*fgkmm;         // not min! Rmin virtual tube
-const Double_t AliITSv11GeometrySDD::fgkLay4Rmax           = 290.*fgkmm;         // not min! Rmax virtual tube
+const Double_t AliITSv11GeometrySDD::fgkLay4Rmin           = 235.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLay4Rmax           = 286.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLay4Length         = (671.+0.)*fgkmm;    // ladder+supporting rings (length of the virtual tube)
 const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength   = 671.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm;
@@ -127,6 +128,10 @@ const Int_t    AliITSv11GeometrySDD::fgkLay4Ndet           = 8;
 const Int_t    AliITSv11GeometrySDD::fgkLay4Nladd          = 22;
 const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH  = 7.5*fgkmm;
 
+const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay3 = fgkLay3DetShortRadius;
+const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay4 = fgkLay4DetShortRadius;
+const Double_t AliITSv11GeometrySDD::fgkDistEndLaddCardsLadd = 0.*fgkmm;
+
 //hybrid 
 const Double_t AliITSv11GeometrySDD::fgkHybridAngle       = 46;           // approx !!!
 // Origine taken at the hybrid corner :
@@ -256,11 +261,11 @@ const Double_t AliITSv11GeometrySDD::fgkEndLadPipeOuterDiam   =   3.*fgkmm;
 //--- The al body of the cooling syst.of the heat exchanger :
 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3    = 112.*fgkmm;   //
 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4    = 125.*fgkmm;   //
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX        =   4.75*fgkmm;    // the arms of the U cooling tube
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX        =   4.75*fgkmm; // the arms of the U cooling tube
 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY        =   6.8*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY    =   1.03*fgkmm; // shift in Y of the arms from the axis
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX    =   0.125*fgkmm;  // shift in X of the arms from the axis
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos     =   8.9*fgkmm; // 
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX    =   0.125*fgkmm;// shift in X of the arms from the axis
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos     =   8.9*fgkmm;  // 
 
 // LV card :
 const Double_t AliITSv11GeometrySDD::fgkLVcardX     = 26.525*fgkmm;
@@ -1093,8 +1098,8 @@ void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
 //   moth->AddNode(lay3Detectors, 1, 0);
 
 
-  TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 );
-  moth->AddNode(endLadder, 1, 0);
+//   TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 );
+//   moth->AddNode(endLadder, 1, 0);
 
 //   TGeoVolumeAssembly *highVCard = CreateHVCard( 4 );
 //   moth->AddNode(highVCard, 1, 0);
@@ -1102,11 +1107,57 @@ void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
 //   TGeoVolumeAssembly *supportRing = CreateSupportRing( 4 );
 //   moth->AddNode(supportRing, 1, 0);
 
-//   TGeoVolumeAssembly *endLadderCards = CreateEndLadderCards( 4 );
+  TGeoVolume *endLadderCards = CreateEndLadderCardsV( 4 );
+  moth->AddNode(endLadderCards, 1, 0);
+
+//   TGeoVolume *endLadderCards = CreateEndLadderCards( 4 );
 //   moth->AddNode(endLadderCards, 1, 0);
 
 //   TGeoVolumeAssembly *carlosCard = CreateCarlosCard( 4 );
 //   moth->AddNode(carlosCard, 1, 0);
+
+
+
+  /*
+  //==================================
+  //--- test of flat cable curvature
+  //==================================
+
+  double angle = 90;
+  AliITSv11GeomCableFlat cable("test", 3, 0.3);
+  cable.SetNLayers(1);
+  cable.SetNLayers(2);
+  cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
+  cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
+  cable.SetInitialNode(endLadderCards);
+
+  Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
+
+  p1[0] = -3;
+  p1[1] = 1;
+  p1[2] = 10;
+
+  p2[0] = 0;
+  p2[1] = 1;
+  p2[2] = 10;
+  cable.AddCheckPoint(endLadderCards, 0, p1, vX);
+  cable.AddCheckPoint(endLadderCards, 1, p2, vX);
+  cable.CreateAndInsertBoxCableSegment(1,angle);
+
+  Double_t p3[3], p4[3];
+
+  p3[0] = 2;
+  p3[1] = 3;
+  p3[2] = 10;
+  cable.AddCheckPoint(endLadderCards, 2, p3, vY);
+  cable.CreateAndInsertCableCylSegment(2,angle);
+
+  p4[0] = 2;
+  p4[1] = 6;
+  p4[2] = 10;
+  cable.AddCheckPoint(endLadderCards, 3, p4, vY);
+  cable.CreateAndInsertCableSegment(3,angle);
+  */
 }
 
 
@@ -1190,23 +1241,33 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) {
     ///////////////////////////////////////////////////
   }
 
+  /*
   //====================================
   // Then the forward rapidity pieces
   // (cooling, Carlos, LV, HV ...)
   //====================================
 
-  Double_t fgkForwardLay3Length = 200*fgkmm;  // this has to be tune !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-  Double_t fgkForwardLay3Rmin = fgkLay3Rmin-10*fgkmm;
-  Double_t fgkForwardLay3Rmax = fgkLay3Rmax;
+  Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm;  // this has to be tune
+  Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
+  Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
 
   TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
   TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
                                                fgkForwardLay3Rmin, fgkForwardLay3Rmax,
                                                fgkForwardLay3Length/2.);
+
+//   TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
+// // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+//   virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
+
+
   TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
                                                  virtualForward3Shape, airSDD);
   TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
                                                  virtualForward3Shape, airSDD);
+//   TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+//   TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
   TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
                                          fgkLay3Length/2+fgkForwardLay3Length/2);
   TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
@@ -1230,22 +1291,167 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) {
     virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
   }
 
+  */
+
+
   if(GetDebug(1)) {
     virtualLayer3->CheckOverlaps(0.01);
-    virtualForward3Pos->CheckOverlaps(0.01);
-    virtualForward3Neg->CheckOverlaps(0.01);
+    //virtualForward3Pos->CheckOverlaps(0.01);
+    //virtualForward3Neg->CheckOverlaps(0.01);
   }
 
   virtualLayer3->SetVisibility(kFALSE);
-  virtualForward3Pos->SetVisibility(kFALSE);
-  virtualForward3Neg->SetVisibility(kFALSE);
+  //virtualForward3Pos->SetVisibility(kFALSE);
+  //virtualForward3Neg->SetVisibility(kFALSE);
+
 
   moth->AddNode(virtualLayer3, 1, 0);
-  moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
-  moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
+  //moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
+  //moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
 }
 
 
+// //________________________________________________________________________
+// void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
+//   //
+//   // Insert the forward pieces of layer 3 in the mother volume. 
+//   // (cooling, Carlos, LV, HV ...)
+//   //
+
+//   if (! moth) {
+//     printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
+//     return;
+//   };
+
+//   TGeoMedium *airSDD = GetMedium("SDD AIR$");
+
+//   if (! fSDDsensor3) CreateBasicObjects();
+
+//   Double_t dPhi = 360./fgkLay3Nladd;
+//   Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
+//   Int_t iLaddMin = 0;
+//   Int_t iLaddMax = fgkLay3Nladd;
+//   if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
+//     iLaddMin = fAddOnlyLadder3min;
+//     iLaddMax = fAddOnlyLadder3max+1;
+//   };
+//   char rotName[30];
+
+
+//   //=================
+
+//   Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm;  // this has to be tune
+//   Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
+//   Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
+
+//   TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
+//   TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
+//                                             fgkForwardLay3Rmin, fgkForwardLay3Rmax,
+//                                             fgkForwardLay3Length/2.);
+
+// //   TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
+// // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+// //   virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
+
+
+//   TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
+//                                               virtualForward3Shape, airSDD);
+//   TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
+//                                               virtualForward3Shape, airSDD);
+// //   TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+// //   TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
+//   TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
+//                                       fgkLay3Length/2+fgkForwardLay3Length/2);
+//   TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
+//                                       -fgkLay3Length/2-fgkForwardLay3Length/2);
+
+//   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+//     Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
+//     Double_t minRadiusDetBox = fgkLay3DetShortRadius;
+//     if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
+//     minRadiusDetBox += detectorsThick/2;
+
+//     sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
+
+//     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+//                                -fgkForwardLay3Length/2, ladderPhi, kTRUE);
+//     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+//                                fgkForwardLay3Length/2, ladderPhi, kFALSE);
+
+//     virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
+//     virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
+//   }
+
+//   if(GetDebug(1)) {
+//     virtualForward3Pos->CheckOverlaps(0.01);
+//     virtualForward3Neg->CheckOverlaps(0.01);
+//   }
+
+//   virtualForward3Pos->SetVisibility(kFALSE);
+//   virtualForward3Neg->SetVisibility(kFALSE);
+
+//   moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
+//   moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
+// }
+
+
+
+//________________________________________________________________________
+void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
+  //
+  // Insert the end-ladder of layer 3 in the mother volume. 
+  // (cooling, Carlos, LV, HV ...)
+  //
+
+  if (! moth) {
+    printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
+    return;
+  };
+
+  if (! fSDDsensor3) CreateBasicObjects();
+
+  Int_t iLaddMin = 0;
+  Int_t iLaddMax = fgkLay3Nladd;
+  if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
+    iLaddMin = fAddOnlyLadder3min;
+    iLaddMax = fAddOnlyLadder3max+1;
+  };
+
+  TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+  TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
+  char rotName[30];
+  Double_t dPhi = 360./fgkLay3Nladd;
+  TGeoVolume* lay3EndLadder = CreateEndLadderCardsV(3);
+
+  for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+    Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
+    Double_t dR = 0;
+    if (iLadd%2 != 0) dR = fgkLay3DetLongRadius-fgkLay3DetShortRadius;
+
+    sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
+
+    TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
+                                   fgkLay3Length/2, ladderPhi, kTRUE);
+    TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
+                                  -fgkLay3Length/2, ladderPhi, kFALSE);
+
+    virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
+    virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
+  }
+
+  if(GetDebug(1)) {
+    virtualForward3Pos->CheckOverlaps(0.01);
+    virtualForward3Neg->CheckOverlaps(0.01);
+  }
+
+  moth->AddNode(virtualForward3Pos, 1);
+  moth->AddNode(virtualForward3Neg, 1);
+}
+
 //________________________________________________________________________
 void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
   //
@@ -1311,14 +1517,15 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
     ///////////////////////////////////////////////////
   }
 
+  /*
   //====================================
   // Then the pieces at forward rapidity
   // (cooling, Carlos, LV, HV ...)
   //====================================
 
-  Double_t fgkForwardLay4Length = 200*fgkmm;  // this has to be tuned !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-  Double_t fgkForwardLay4Rmin = fgkLay4Rmin-10*fgkmm;
-  Double_t fgkForwardLay4Rmax = fgkLay4Rmax;
+  Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm;  // this has to be tuned
+  Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
+  Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
 
   TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
   TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
@@ -1328,6 +1535,9 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
                                                  virtualForward4Shape, airSDD);
   TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
                                                  virtualForward4Shape, airSDD);
+//   TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+//   TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
   TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
                                          fgkLay4Length/2+fgkForwardLay4Length/2);
   TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
@@ -1350,16 +1560,146 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
     virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
     virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
   }
+  */
 
   if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01);
 
   virtualLayer4->SetVisibility(kFALSE);
-  virtualForward4Pos->SetVisibility(kFALSE);
-  virtualForward4Neg->SetVisibility(kFALSE);
+  //virtualForward4Pos->SetVisibility(kFALSE);
+  //virtualForward4Neg->SetVisibility(kFALSE);
 
   moth->AddNode(virtualLayer4,1,0);
-  moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
-  moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+  //moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
+  //moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+}
+
+
+// //________________________________________________________________________
+// void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
+//   //
+//   // Insert the layer 4 in the mother volume. This is a virtual volume
+//   // containing ladders of layer 4 and the supporting rings
+//   // (cooling, Carlos, LV, HV ...)
+//   //
+
+//   if (! moth) {
+//     printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
+//     return;
+//   };
+
+//   TGeoMedium *airSDD = GetMedium("SDD AIR$");
+
+//   if (! fSDDsensor3) CreateBasicObjects();
+
+//   Double_t dPhi = 360./fgkLay4Nladd;
+//   Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
+
+//   // placing virtual ladder and detectors volumes following ladder 
+//   // ordering convention
+//   char rotName[20];
+//   Int_t iLaddMin = 0;
+//   Int_t iLaddMax = fgkLay4Nladd;
+//   if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
+//     iLaddMin = fAddOnlyLadder4min;
+//     iLaddMax = fAddOnlyLadder4max+1;
+//   }
+
+//   //=================
+//   Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm;  // this has to be tuned
+//   Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
+//   Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
+
+//   TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
+//   TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
+//                                             fgkForwardLay4Rmin, fgkForwardLay4Rmax,
+//                                             fgkForwardLay4Length/2.);
+//   TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
+//                                               virtualForward4Shape, airSDD);
+//   TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
+//                                               virtualForward4Shape, airSDD);
+// //   TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+// //   TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
+//   TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
+//                                       fgkLay4Length/2+fgkForwardLay4Length/2);
+//   TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
+//                                       -fgkLay4Length/2-fgkForwardLay4Length/2);
+
+//   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+//     Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
+//     Double_t minRadiusDetBox = fgkLay4DetShortRadius;
+//     if (iLadd%2 != 0)
+//       minRadiusDetBox = fgkLay4DetLongRadius;
+//     minRadiusDetBox += detBoxThickness/2;
+
+//     sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
+
+//     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+//                                -fgkForwardLay4Length/2, ladderPhi, kTRUE);
+//     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+//                                 fgkForwardLay4Length/2, ladderPhi, kFALSE);
+//     virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
+//     virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
+//   }
+
+//   virtualForward4Pos->SetVisibility(kFALSE);
+//   virtualForward4Neg->SetVisibility(kFALSE);
+
+//   moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
+//   moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+// }
+
+
+//________________________________________________________________________
+void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
+  //
+  // Insert the end-ladder of layer 4 in the mother volume.
+  // (cooling, Carlos, LV, HV ...)
+  //
+
+  if (! moth) {
+    printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
+    return;
+  };
+
+  if (! fSDDsensor3) CreateBasicObjects();
+
+  // placing virtual ladder and detectors volumes following ladder 
+  // ordering convention
+  Int_t iLaddMin = 0;
+  Int_t iLaddMax = fgkLay4Nladd;
+  if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
+    iLaddMin = fAddOnlyLadder4min;
+    iLaddMax = fAddOnlyLadder4max+1;
+  }
+
+  TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+  TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
+  char rotName[30];
+  Double_t dPhi = 360./fgkLay4Nladd;
+  TGeoVolume* lay4EndLadder = CreateEndLadderCardsV(4);
+
+  for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+    Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
+    Double_t dR = 0;
+    if (iLadd%2 != 0)
+      dR = fgkLay4DetLongRadius-fgkLay4DetShortRadius;
+
+    sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
+
+    TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
+                                  fgkLay4Length/2, ladderPhi, kTRUE);
+    TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
+                                  -fgkLay4Length/2, ladderPhi, kFALSE);
+    virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
+    virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2, ctEndLaddNeg);
+  }
+
+  moth->AddNode(virtualForward4Pos, 1);
+  moth->AddNode(virtualForward4Neg, 1);
 }
 
 
@@ -1449,7 +1789,7 @@ TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
        rotation = 90-fgkHybridAngle; 
        digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
       } else
-       digitCableA[iSegment].CreateAndInsertBoxCableSegment(iPt);
+       digitCableA[iSegment].CreateAndInsertCableSegment(iPt);
 
     };
     
@@ -1459,7 +1799,7 @@ TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
        rotation = fgkHybridAngle-90; 
        digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
       } else
-       digitCableB[iSegment].CreateAndInsertBoxCableSegment(iPt);
+       digitCableB[iSegment].CreateAndInsertCableSegment(iPt);
     };
   };
   
@@ -1996,7 +2336,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
   // Return a TGeoVolume* containing a segment of a ladder.
   //
 
-  TGeoMedium *phynoxSDD       = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+  TGeoMedium *phynoxSDD       = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!!
   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
   TGeoMedium *airSDD          = GetMedium("SDD AIR$");
 
@@ -3826,8 +4166,8 @@ TGeoVolumeAssembly*  AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) {
 // and their cooling system 
 //
 
-  TGeoMedium *alCu12SDD       = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-  TGeoMedium *phynoxSDD       = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+  TGeoMedium *alCu12SDD       = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!
+  TGeoMedium *phynoxSDD       = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!
   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
 
   TGeoVolumeAssembly *endLadderCards = new TGeoVolumeAssembly("endLadderCards");
@@ -4013,50 +4353,234 @@ TGeoVolumeAssembly*  AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) {
     endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
   }
 
+  return endLadderCards;
+}
 
 
-  
+//________________________________________________________________________
+TGeoVolume*  AliITSv11GeometrySDD::CreateEndLadderCardsV(Int_t iLay) {
+// 
+// return an Pcon containing the LV, HV and Carlos cards of one ladder
+// and their cooling system 
+//
+
+  TGeoMedium *alCu12SDD       = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!
+  TGeoMedium *phynoxSDD       = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!
+  TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
+  TGeoMedium *airSDD          = GetMedium("SDD AIR$");
+
+  Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
+  Double_t endLadPipeArmZ    = fgkEndLadPipeArmZLay3;
+  Int_t    nCards = 3;
+  Double_t rREF   = fgkEndLaddCardsShortRadiusLay3;
+  // reference radius corresponding to local y=0
+
+  if (iLay==4) {
+    endLadPipeUlength = fgkEndLadPipeUlengthLay4;
+    endLadPipeArmZ = fgkEndLadPipeArmZLay4;
+    nCards = 4;
+    rREF = fgkEndLaddCardsShortRadiusLay4;
+  }
+
+  Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
+                          +fgkEndLadPipeArmBoxDX);
+  Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
+                          +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
+
+  Double_t rMin   = rREF + cardLVyShift;
+  // (The LV card is defining rMin because it is the lower object)
 
-  /*
-  //==================================
-  //--- test of flat cable curvature
   //==================================
+  //--- The Pcon container
+
+  // minimum angle of the Pcon :
+  Double_t tanDPhi = ((fgkEndLadPipeUwidth/2+fgkEndLadPipeArmX/2) /
+                    (rREF-fgkEndLadPipeArmY/2) );
+  Double_t dphi = 2*TMath::ATan(tanDPhi)*TMath::RadToDeg();
+  Double_t phi0 = 90-dphi/2;
+  Double_t coolUzPos = fgkEndLadPipeOuterDiam/2 + fgkDistEndLaddCardsLadd; // it is the z coord of the axis
+                                                        // of the U colling pipe in its center
+  Double_t zMax = endLadPipeUlength+coolUzPos;
+  Double_t rMax = rMin + fgkLVcardY;
+  rMax = TMath::Sqrt(rMax*rMax + cardLVxShift*cardLVxShift);
+
+  TGeoPcon *containerShape = new TGeoPcon("EndLadderCcontainerShape", phi0, dphi, 6);
+   //DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+  containerShape->DefineSection(0,  fgkDistEndLaddCardsLadd, rMin, rMax);
+  containerShape->DefineSection(1,  endLadPipeArmZ+2*fgkEndLadPipeRadius, rMin, rMax);
+  containerShape->DefineSection(2,  endLadPipeArmZ+2*fgkEndLadPipeRadius, rREF-1.*fgkmm, rMax);
+  containerShape->DefineSection(3,  zMax, rREF-1.*fgkmm, rMax);
+  // the following is dirty but works ...
+  containerShape->DefineSection(4,  zMax,          rREF+fgkCarlosCardZ1/2, rMax);
+  containerShape->DefineSection(5,  zMax+6.*fgkmm, rREF+fgkCarlosCardZ1/2, rMax);
+
+  TGeoVolume *endLadderCards = new TGeoVolume("endLadderCards",containerShape,airSDD);
+  endLadderCards->SetVisibility(kFALSE);
 
-  double angle = 90;
-  AliITSv11GeomCableFlat cable("test", 3, 0.3);
-  cable.SetNLayers(1);
-  cable.SetNLayers(2);
-  cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
-  cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
-  cable.SetInitialNode(endLadderCards);
+  //=*********************************
+  //--- The rounded pipe for the end ladder card cooling
 
-  Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
+  AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
+  endLadderPipe.SetNLayers(2); 
+  endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
+  endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
 
-  p1[0] = -3;
-  p1[1] = 1;
-  p1[2] = 10;
+  Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos};
+  Double_t vectA[3]  = {0,0,1};
 
-  p2[0] = 0;
-  p2[1] = 1;
-  p2[2] = 10;
-  cable.AddCheckPoint(endLadderCards, 0, p1, vX);
-  cable.AddCheckPoint(endLadderCards, 1, p2, vX);
-  cable.CreateAndInsertBoxCableSegment(1,angle);
+  Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos};
+  Double_t vectB[3]  = {0,0,1};
 
-  Double_t p3[3], p4[3];
+  Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, rREF, coolUzPos};
+  Double_t vectC[3]  = {1,0,0};
 
-  p3[0] = 2;
-  p3[1] = 3;
-  p3[2] = 10;
-  cable.AddCheckPoint(endLadderCards, 2, p3, vY);
-  cable.CreateAndInsertCableCylSegment(2,angle);
+  Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, rREF, coolUzPos};
+  Double_t vectD[3]  = {-1,0,0};
 
-  p4[0] = 2;
-  p4[1] = 6;
-  p4[2] = 10;
-  cable.AddCheckPoint(endLadderCards, 3, p4, vY);
-  cable.CreateAndInsertCableSegment(3,angle);
-  */
+  Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, rREF, fgkEndLadPipeRadius+coolUzPos};
+  Double_t vectE[3]  = {0,0,-1};
+
+  Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,rREF, endLadPipeUlength+coolUzPos};
+  Double_t vectF[3]  = {0,0,-1};
+
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
+  endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
+
+  endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
+  //endLadderPipe.CreateAndInsertCableSegment( 1);
+  endLadderPipe.CreateAndInsertTubeSegment( 1);
+  //endLadderPipe.CreateAndInsertCableSegment( 2);
+  endLadderPipe.CreateAndInsertTorusSegment( 2);
+  //endLadderPipe.CreateAndInsertCableSegment( 3);
+  endLadderPipe.CreateAndInsertTubeSegment( 3);
+  //endLadderPipe.CreateAndInsertCableSegment( 4);
+  endLadderPipe.CreateAndInsertTorusSegment( 4);
+  //endLadderPipe.CreateAndInsertCableSegment( 5);
+  endLadderPipe.CreateAndInsertTubeSegment( 5);
+
+  TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
+                                        fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
+  TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
+                                   fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
+
+  TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
+                                                           - fgkEndLadPipeArmBoxDX,
+                                                            fgkEndLadPipeArmBoxDY,0);
+  TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
+                                                           fgkEndLadPipeArmBoxDX,
+                                                           fgkEndLadPipeArmBoxDY,0);
+  endLadPipeArmBoxDY1->RegisterYourself();
+  endLadPipeArmBoxDY2->RegisterYourself();
+
+  if(GetDebug(3)) { // Remove compiler warning.
+    endLadPipeArmBox->InspectShape();
+    endLadPipeArmTube->InspectShape();
+  }
+
+  TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
+                                          "endLadPipeArmBox:endLadPipeArmBoxDY1"
+                                          "- endLadPipeArmTube");
+  TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
+                                          "endLadPipeArmBox:endLadPipeArmBoxDY2"
+                                          "- endLadPipeArmTube");
+
+  TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
+                                              endLadPipeArm1, alCu12SDD);
+  TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
+                                              endLadPipeArm2, alCu12SDD);
+  vEndLadPipeArm1->SetLineColor(2);
+  vEndLadPipeArm2->SetLineColor(2);
+
+  Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
+                  +fgkEndLadPipeArmZpos);
+
+  TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
+                                         -fgkEndLadPipeUwidth/2,rREF,armZ);
+  TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
+                                          fgkEndLadPipeUwidth/2,rREF,armZ);
+
+  endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
+  endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
+
+  //=*********************************
+  //--- LV cards
+  TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
+  TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
+
+  Double_t spaceBetweenCards = 0.2*fgkmm; 
+
+
+  Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
+                         +fgkLVcoolZ1*2.);
+
+  Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
+                          +coolUzPos+1.25*fgkmm;
+  // Position in z of the first LVB with respect to the start of the cooling
+  // rectangular arm, coming  (from inside of the ladder)
+  // The cards are added one after the other
+
+  for (Int_t iCard=0; iCard<nCards; iCard++) {
+
+    Double_t cardLVzShift = firstLVCardZ + 
+      Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
+
+    TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
+                                            cardLVyShift+rREF, cardLVzShift);
+    TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
+                                            cardLVyShift+rREF, cardLVzShift);
+
+    endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
+    endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
+  }
+
+  //=*********************************
+  //--- HV cards
+  TGeoVolumeAssembly *cardHV = fCardHV;
+
+  Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
+                      + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
+  // shift of the HV card in local y w.r.t the local y=0 (center of cooling tube)
+
+  Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
+                               -(fgkHVCardCeramZ)/2); 
+
+  for (Int_t iCard=0; iCard<nCards; iCard++) {
+
+    Double_t fact = iCard*2.+1.;
+    Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
+                        + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
+    TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy+rREF, coolHVdz);
+    endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
+  }
+
+  //=*********************************
+  //--- Carlos card
+
+  TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
+//   TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
+//                                              0, -fgkCarlosSuppAngle, 0);
+
+  Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
+  Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
+                              fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
+  // position in z of the first Carlos board, coming  from inside of the ladder
+
+  Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 + 
+                          fgkEndLadPipeArmBoxDY);
+
+  for (Int_t iCard=0; iCard<nCards; iCard++) {
+
+    Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
+                           iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
+    TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy+rREF,carloszPos,
+                                                  (TGeoRotation*) fCommonTr[0]);
+
+    endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
+  }
 
   return endLadderCards;
 }
index 8df9f90..6066e08 100755 (executable)
@@ -46,6 +46,8 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry {
   // Main functions
   virtual void  Layer3(TGeoVolume *moth);
   virtual void  Layer4(TGeoVolume *moth);
+  virtual void  ForwardLayer3(TGeoVolume *moth);
+  virtual void  ForwardLayer4(TGeoVolume *moth);
   virtual Int_t ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD,
                                      Int_t startMod);
   virtual Int_t GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const;
@@ -78,6 +80,7 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry {
   virtual TGeoVolume*          CreateLadderSegment(Int_t iLay, Int_t iSeg);
   virtual TGeoVolumeAssembly*  CreateEndLadder(Int_t iLay);
   virtual TGeoVolumeAssembly*  CreateEndLadderCards(Int_t iLay);
+  virtual TGeoVolume*          CreateEndLadderCardsV(Int_t iLay);
   virtual TGeoVolumeAssembly*  CreateSupportRing(Int_t iLay);
 
   // Create some basic objects : 
@@ -187,6 +190,10 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry {
   static const Double_t fgkLay4LaddTopCornerEnd;  // Ends of ladder 3
   static const Double_t fgkLay4ZPlusEndLength;    // ===
 
+  static const Double_t fgkEndLaddCardsShortRadiusLay3; // ref radius of end ladder cards
+  static const Double_t fgkEndLaddCardsShortRadiusLay4; // ref radius  of end ladder cards
+  static const Double_t fgkDistEndLaddCardsLadd;        // dist. between U cooling tube and ladder
+
   static const Double_t fgkSegmentLength;         // length of 1 ladder seg.
   static const Double_t fgkLadderWidth;           // carbon fiber structure 
   static const Double_t fgkLadderHeight;          // including bottom beam
index 5ee182a..092447a 100644 (file)
 #include "TGeoCompositeShape.h"
 #include "TGeoTube.h"
 #include "TGeoBBox.h"
+#include "TGeoXtru.h"
 #include "AliITSv11GeometrySSD.h"
 /////////////////////////////////////////////////////////////////////////////////
+// Names of the Sensitive Volumes of Layer 5 and Layer 6
+/////////////////////////////////////////////////////////////////////////////////
+const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
+const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
+/////////////////////////////////////////////////////////////////////////////////
 //Parameters for SSD Geometry
 /////////////////////////////////////////////////////////////////////////////////
 // Layer5 (lengths are in mm and angles in degrees)
@@ -59,42 +65,45 @@ const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100*fgkmm
 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength        =   fgkSSDChipLength;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth         =   fgkSSDChipWidth;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength     = fgkSSDChipLength;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth      =  fgkSSDChipWidth;
 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // Stiffener (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500*fgkmm;
+//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   =   1.600*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   = 1.600*fgkmm; 
 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   0.700*fgkmm; // multiplied by 0.5  
 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32*fgkmm, 
-                                                                     0.33*fgkmm};
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   = 0.44*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       = 2.16*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        = 3.60*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = 
+                                                                                                          {44.32*fgkmm, 0.33*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   =       0.44*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       =       2.16*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        =       3.60*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       = 
-                                                   0.25*fgkSSDStiffenerHeight;
+                                                                                                         0.25*fgkSSDStiffenerHeight;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight     =      0.030*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight     =   0.002*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // Cooling Block (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = 
-                                                                                                        {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =  
+                                                                                {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] = 
-                                                                                                                   {1.000*fgkmm, 0.120*fgkmm};
+                                                                                                         {1.000*fgkmm, 0.120*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] = 
-                                                                                                                       {1.900*fgkmm, 0.400*fgkmm};
+                                                                                                         {1.900*fgkmm, 0.400*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =  
                                                                                                                                         1.500*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =  
@@ -103,44 +112,44 @@ const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =
 // SSD Sensor (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       = 
-                                                          "SSDSensorSensitiveVol";
+                                                                                                                "SSDSensorSensitiveVol";
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         = 
                                                                                                   fgkSSDSensorLength-39.1*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength      = 1.*fgkmm; 
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth       = 1.*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength    = 1.*fgkmm; 
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth     = 1.*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // Flex (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000*fgkmm; 
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        = 
-                       {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
-                                               +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
-                        0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
-                                               +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000*fgkmm,
-                                                 9.500*fgkmm, 10.000*fgkmm};
+                       {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                                + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+                        0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                                + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
+                                                                          - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         = 
-                                                                                                                {  9.340*fgkmm,  5.380*fgkmm};
+                                                                                                  {  9.340*fgkmm,  5.380*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
-                                                                                                                {  0.030*fgkmm,  0.020*fgkmm};      
+                                                                                                  {  0.030*fgkmm,  0.020*fgkmm};      
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] = 
-                                                                                  {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
+                        {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
-                                                                                                          {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
+                                                                                  {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
 /////////////////////////////////////////////////////////////////////////////////
 // SSD Ladder Cable (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =   23.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =     23.5*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // SSD Module (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  = 
-                                                                                                                  { 1.000*fgkmm, 3.900*fgkmm};
+                                                                                                        { 1.000*fgkmm, 3.900*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =  
                                                                                                                                        45.600*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =  
@@ -148,76 +157,87 @@ const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =
 /////////////////////////////////////////////////////////////////////////////////
 // Sensor Support (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                = 
-                                                                                                                                          5.800*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength                    = 
+                                                                                                                                        5.800*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =  
-                                                                                                                                          2.000*fgkmm;
+                                                                                                                                        2.000*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
-                                                                                                                    { 4.620*fgkmm, 5.180*fgkmm};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = 
-                                                                                                                    { 0.450*fgkmm, 0.450*fgkmm};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition       =  
-                                                                         0.5*(fgkSSDModuleSensorSupportDistance
-                                                              +    fgkSSDSensorSideSupportThickness[0])
-                                                                  -           fgkSSDSensorSideSupportLength;
+                                                                                                    { 4.620*fgkmm, 5.180*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2]   = 
+                                                                                                        { 0.450*fgkmm, 0.450*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition       
+                                                               = 0.5 * (fgkSSDModuleSensorSupportDistance
+                                                           +  fgkSSDSensorSideSupportThickness[0])
+                                                               -  fgkSSDSensorSideSupportLength;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength      =  
-                                                                                                                                          5.250*fgkmm;
+                                                                                                                                   5.250*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
-                                                                                                                                      1.680*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]    =
-          {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
-          fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
-   {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
+                                                                                                                                       1.680*fgkmm;
+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*fgkmm;
+                                                                                                                                  19.000*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // Chip Cables (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   = 
-                                                {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
+                                 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   = 
-                                               {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
-  -  (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
-  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
-  -   fgkSSDChipHeight-fgkSSDSensorHeight,
-      fgkSSDModuleCoolingBlockToSensor
-  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
-  -   fgkSSDChipHeight-fgkSSDSensorHeight};
+                                 {  0.014*fgkmm,  0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
+                                                                 -  (fgkSSDSensorSideSupportHeight[1]
+                                                                 -   fgkSSDSensorSideSupportHeight[0])
+                                                                 -   fgkSSDCoolingBlockHoleCenter
+                                                                 -   fgkSSDStiffenerHeight
+                                                                 -   fgkSSDChipHeight-fgkSSDSensorHeight,
+                                                                         fgkSSDModuleCoolingBlockToSensor
+                                                                 -   fgkSSDCoolingBlockHoleCenter
+                                                                 -       fgkSSDStiffenerHeight
+                                                                 -   fgkSSDChipHeight-fgkSSDSensorHeight};
 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    = 
-                                                                                                { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
+                                           { 11.000*fgkmm,  0.800*fgkmm,  0.600*fgkmm};
 /////////////////////////////////////////////////////////////////////////////////
 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
-                                                                                                                                          3.820*fgkmm;
+                                                                                                                                       3.820*fgkmm;
+//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
+//                                                                                                                                        3.780;
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           = 
-                                                                         fgkSSDSensorLength-fgkSSDSensorOverlap;
+                                                                                fgkSSDSensorLength-fgkSSDSensorOverlap;
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         = 
-                                                                                                                        {  0.86*fgkmm,  0.30*fgkmm};
+                                                                                                       {  0.86*fgkmm,  0.30*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        = 
-                                                                                                                        { 30.00, 90.00};
+                                                                                                                               { 30.00, 90.00};
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport = 
-                                                                                                                                           1.78*fgkmm;
+                                                                                                                                        1.78*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 //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::fgkCarbonFiberTriangleLength          
+                                                                  = fgkSSDModuleSensorSupportDistance
+                                                                  - 2. * fgkCarbonFiberJunctionToSensorSupport;  
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   = 
-                                                                                                                  {  0.751*fgkmm,  0.482*fgkmm};
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength       =  
-                                                                                                                                          1.630*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth            = 
-                                                                                                                                          0.950*fgkmm;
-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;
+                                                                                                 {  0.751*fgkmm,  0.482*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength  = 
+                                                                                                                                       1.630*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =   0.950*fgkmm;
+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)
 /////////////////////////////////////////////////////////////////////////////////
@@ -230,80 +250,84 @@ const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation  
                                                                                          = 0.5*fgkCarbonFiberSupportWidth;
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth   
-                                                                = fgkCarbonFiberJunctionWidth
-                                 - 2.*(fgkCarbonFiberLowerSupportWidth
-                                                                + fgkCarbonFiberLowerSupportVolumeSeparation);
+                                                                       = fgkCarbonFiberJunctionWidth
+                                                                       - 2. * (fgkCarbonFiberLowerSupportWidth
+                                                                       + fgkCarbonFiberLowerSupportVolumeSeparation);
 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2] 
-                                                                = {fgkCarbonFiberLowerSupportWidth
-                                                                +  fgkCarbonFiberLowerSupportVolumeSeparation,
-                                                                       fgkCarbonFiberLowerSupportWidth
-                                                                +  fgkCarbonFiberLowerSupportVolumeSeparation                                                  
-                                                                +  fgkCarbonFiberLowerSupportTransverseWidth};
+                                                                       = {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)};
+                                                          {0.5 * (fgkSSDLay5LadderLength
+                                                                       -  fgkSSDLay5SensorsNumber
+                                                                       *  fgkCarbonFiberJunctionWidth
+                                                                       -  fgkCarbonFiberLowerSupportWidth),
+                                                               0.5 * (fgkSSDLay5LadderLength
+                                                                       -  fgkSSDLay5SensorsNumber
+                                                                       *  fgkCarbonFiberJunctionWidth
+                                                                       +  fgkCarbonFiberLowerSupportWidth)};
 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] = 
-               {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
-                fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
+                                               {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
+                                                fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] = 
-                                                  {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
-                                                  fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
+                                               {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
+                                                fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
 /////////////////////////////////////////////////////////////////////////////////
 // Cooling Tube Support (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax          =  1.45*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax      =  1.45*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin          
                                                                                          = fgkSSDCoolingBlockHoleRadius[0];
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength        =  8.55*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight        =  0.85*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth         =  2.00*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength    =  8.55*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight    =  0.85*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth     =  2.00*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    = 
-                                      fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70*fgkmm;
+                                        fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 
+                                                                                                                                         11.70*fgkmm;
 /////////////////////////////////////////////////////////////////////////////////
 // Cooling Tube (lengths are in mm and angles in degrees)
 /////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax       = 
-                                                                                                         fgkCoolingTubeSupportRmin;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin       =  0.96*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength     = 
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin =  0.96*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength = 
                                                                                                        fgkCarbonFiberJunctionWidth;
 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation = 
-                                       fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
+                                                                        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*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
+                                                                                  { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
-                                                                                                         {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
+                                                          {  4.0*fgkmm,  8.0*fgkmm,  5.0*fgkmm,  0.2*fgkmm};
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =   
-                                                                                                                                                  20.0*fgkmm;
+                                                                                                                                         20.0*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =   
-                                                                                                                                                  40.0;
+                                                                                                                                                   40.0;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  = 
                   0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =    
-                                                                                                                                                       2.5*fgkmm;
+                                                                                                                                         2.5*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    = 
-                                                                                                                                 { 56.0*fgkmm, 12.0*fgkmm}; 
+                                                                                                         { 56.0*fgkmm, 12.0*fgkmm}; 
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     = 
-                                                                                                                                 {  5.0*fgkmm,  2.9*fgkmm}; 
+                                                                                                     {  5.0*fgkmm,  2.9*fgkmm}; 
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           = 
-                                                                                                                                                       1.0*fgkmm;
+                                                                                                                                         1.0*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =   
-                                                                                                                                                       6.0*fgkmm;
+                                                                                                                                         6.0*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =  
-                                                                                                                                                       4.0*fgkmm;
+                                                                                                                                         4.0*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
-                                                                       {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
+                                                         {  1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
 /////////////////////////////////////////////////////////////////////////////////
 ClassImp(AliITSv11GeometrySSD)
 /////////////////////////////////////////////////////////////////////////////////
@@ -330,21 +354,38 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD():
   fSSDCoolingTubeWater(),
   fSSDCoolingTubePhynox(),
   fSSDMountingBlockMedium(),
-  fMotherVol(0),
+  fSSDAir(),
+  fCreateMaterials(kFALSE),
+  fTransformationMatrices(kFALSE),
+  fBasicObjects(kFALSE),
+  fcarbonfiberjunction(),
+  fcoolingtubesupport(),
+  fhybridmatrix(),
+  fssdcoolingblocksystem(),
+  fcoolingblocksystematrix(),
+  fssdstiffenerflex(),
+  fssdendflex(),
+  fendladdermountingblock(),
+  fSSDSensor5(),
+  fSSDSensor6(),
+  fSSDLayer5(),        
+  fSSDLayer6(),
+  fMotherVol(),
   fColorCarbonFiber(4),
   fColorRyton(5),
-  fColorPhynox(5),
+  fColorPhynox(14),
   fColorSilicon(3),
-  fColorAl(7),
+  fColorAl(38),
   fColorKapton(6),
   fColorPolyhamide(5),
   fColorStiffener(9),
-  fColorEpoxy(30)
+  fColorEpoxy(30),
+  fColorWater(7),
+  fColorG10(41)
 {
   ////////////////////////
   // Standard constructor
   ////////////////////////
-  CreateMaterials();
 }
 /////////////////////////////////////////////////////////////////////////////////
 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
@@ -370,6 +411,22 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
   fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
   fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
   fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
+  fSSDAir(s.fSSDAir),
+  fCreateMaterials(s.fCreateMaterials),
+  fTransformationMatrices(s.fTransformationMatrices),
+  fBasicObjects(s.fBasicObjects),
+  fcarbonfiberjunction(s.fcarbonfiberjunction),
+  fcoolingtubesupport(s.fcoolingtubesupport),
+  fhybridmatrix(s.fhybridmatrix),
+  fssdcoolingblocksystem(s.fssdcoolingblocksystem),
+  fcoolingblocksystematrix(s.fcoolingblocksystematrix),
+  fssdstiffenerflex(s.fssdstiffenerflex),
+  fssdendflex(s.fssdendflex),
+  fendladdermountingblock(s.fendladdermountingblock),
+  fSSDSensor5(s.fSSDSensor5),
+  fSSDSensor6(s.fSSDSensor6),
+  fSSDLayer5(s.fSSDLayer5),    
+  fSSDLayer6(s.fSSDLayer6),
   fMotherVol(s.fMotherVol),
   fColorCarbonFiber(s.fColorCarbonFiber),
   fColorRyton(s.fColorRyton),
@@ -379,12 +436,13 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
   fColorKapton(s.fColorKapton),
   fColorPolyhamide(s.fColorPolyhamide),
   fColorStiffener(s.fColorStiffener),
-  fColorEpoxy(s.fColorEpoxy)
+  fColorEpoxy(s.fColorEpoxy),
+  fColorWater(s.fColorWater),
+  fColorG10(s.fColorG10)
 {
   ////////////////////////
   // Copy Constructor
   ////////////////////////
-  CreateMaterials();
 }
 /////////////////////////////////////////////////////////////////////////////////
 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
@@ -401,492 +459,553 @@ operator=(const AliITSv11GeometrySSD &s){
   return *this;
  */
 }
-/////////////////////////////////////////////////////////////////////////////////
-// Setting the transformation Matrices
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for SSD Sensor Support   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters SSDSensorSupportAssembly:
-  ////////////////////////////////////////////////////////
-  const Double_t kssdsensorsupporttransx[3] = {-0.5*fgkSSDSensorSideSupportWidth,
-                                                                  0.5*fgkSSDSensorSideSupportWidth,
-                                                          0.5*fgkSSDSensorCenterSupportThickness[0]
-                                                                         -    fgkSSDSensorCenterSupportPosition}; 
-  const Double_t kssdsensorsupporttransy[3] = 
-                                                                          {0.5*fgkSSDSensorSideSupportThickness[0],
-                                                          -0.5*fgkSSDSensorSideSupportThickness[0]
-                                                              -fgkSSDModuleSensorSupportDistance,
-                                                           0.5*fgkSSDSensorCenterSupportWidth
-                                                                          -0.5*fgkSSDModuleSensorSupportDistance}; 
-  const Double_t kssdsensorsupporttransz[3] = {0.,0.,
-                                                                               fgkSSDSensorCenterSupportThickness[0]}; 
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters SSDSensorSupportAssembly:
-  ////////////////////////////////////////////////////////  
-  const Double_t kssdsensorsupportrotphi[3]   = {   0., 180., 270.};
-  const Double_t kssdsensorsupportrottheta[3] = {  90.,  90.,  90.};
-  const Double_t kssdsensorsupportrotpsi[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,
-                                                                       kssdsensorsupporttransx[i],
-                                                                       kssdsensorsupporttransy[i],
-                                                                       kssdsensorsupporttransz[i],
-                                                                       new TGeoRotation(ssdsensorsupportrotname,
-                                                                                                          kssdsensorsupportrotphi[i],
-                                                                                                          kssdsensorsupportrottheta[i],
-                                                                                                   kssdsensorsupportrotpsi[i]));
-           fSSDSensorSupportCombiTransMatrix[i] = ssdsensorsupportlocalmatrix[i];
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::CreateTransformationMatrices(){
+  ///////////////////////////////////////////////////////////////////////  
+  // Method generating the trasformation matrix for the whole SSD Geometry   
+  ///////////////////////////////////////////////////////////////////////  
+  // Setting some variables for Carbon Fiber Supportmatrix creation
+  //////////////////////////////////////////////////////////////////////
+  Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
+                                                                                  * CosD(fgkCarbonFiberJunctionAngle[0]);
+  Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
+                                                                +      fgkCarbonFiberSupportTopEdgeDist[0]
+                                                                +      fgkCarbonFiberSupportWidth);
+  Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
+                                                                       * TanD(fgkCarbonFiberJunctionAngle[0]);
+  TGeoRotation* carbonfiberot[3];
+  for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
+  carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
+  carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
+  carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
+  Double_t transvector[3] = {fgkCarbonFiberTriangleLength
+                                                 *  CosD(fgkCarbonFiberTriangleAngle),0.,
+                                                 -  fgkCarbonFiberTriangleLength
+                                                 *      SinD(fgkCarbonFiberTriangleAngle)};
+  ///////////////////////////////////////////
+  //Setting Local Translations and Rotations: 
+  ///////////////////////////////////////////
+  TGeoCombiTrans* localcarbonfibersupportmatrix[3]; 
+  localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
+                                                                        0.5*carbonfibersupportheight,NULL);    
+  localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
+                                                                        2.*symmetryplaneposition+transvector[1],
+                                                                        transvector[2], carbonfiberot[2]);
+  localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
+  /////////////////////////////////////////////////////////////
+  // Carbon Fiber Support Transformations
+  /////////////////////////////////////////////////////////////
+  const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
+  for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){ 
+               fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
+               for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
+                       fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
+  }            
+  /////////////////////////////////////////////////////////////
+  // Carbon Fiber Junction Transformation
+  /////////////////////////////////////////////////////////////
+  const Int_t kcarbonfiberjunctionmatrixnumber = 2;
+  TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
+  TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
+  TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
+  for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){ 
+       localcarbonfiberjunctionmatrix[i] = 
+                                               new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
+       localcarbonfiberjunctionrot[i] = 
+                                               new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
+       localcarbonfiberjunctiontrans[i] = 
+                                               new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for SSD Module   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters SSDModuleAssembly:
-  ////////////////////////////////////////////////////////
-  const Double_t kssdmoduletransx[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 kssdmoduletransy[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 kssdmoduletransz[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 kssdmodulerotphi[7]   = {   0.,   0.,  90.,   0.,   0.,  90., 180.};
-  const Double_t kssdmodulerottheta[7] = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
-  const Double_t kssdmodulerotpsi[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],
-                                                                          kssdmoduletransx[i],
-                                                                          kssdmoduletransy[i],
-                                                                          kssdmoduletransz[i],
-                                                                          new TGeoRotation(ssdmodulerotname[i],
-                                                                                                                     kssdmodulerotphi[i],
-                                                                                                       kssdmodulerottheta[i],
-                                                                                                       kssdmodulerotpsi[i]));
-    fSSDModuleCombiTransMatrix[i] = ssdmodulelocalmatrix[i];
+  ///////////////////////
+  // Setting Translations
+  ///////////////////////
+  localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
+  localcarbonfiberjunctiontrans[1][0] = 
+                                new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
+  localcarbonfiberjunctiontrans[2][0] = 
+                                new TGeoTranslation(fgkCarbonFiberTriangleLength
+                                * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
+                                fgkCarbonFiberTriangleLength
+                                * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
+  localcarbonfiberjunctiontrans[0][1] = 
+                                new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
+  localcarbonfiberjunctiontrans[1][1] = 
+                                new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
+  localcarbonfiberjunctiontrans[2][1] = 
+                                new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
+  ////////////////////
+  // Setting Rotations
+  ////////////////////
+  for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
+               for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
+                       localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
+  for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
+       localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
+  localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
+  localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
+  localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
+  ////////////////////////////////////////
+  // Setting Carbon Fiber Junction matrix 
+  ////////////////////////////////////////
+  for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
+               fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
+               for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
+                       localcarbonfiberjunctionmatrix[i][j] = 
+                       new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
+                                                          *localcarbonfiberjunctionrot[i][j]);
+                   fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
+        }
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for Carbon Fiber Junction   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters CarbonFiberJunction:
-  ////////////////////////////////////////////////////////
-  const Double_t kcarbonfiberjunctiontransx[3] = 
-                               {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
-                                * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
-  const Double_t kcarbonfiberjunctiontransy[3] = 
-                                                                         {  0.0, 0.0,fgkCarbonFiberTriangleLength
-                                *   TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
-  const Double_t kcarbonfiberjunctiontransz[3] = {  0.0,  0.0,  0.0};
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters CarbonFiberJunction:
-  ////////////////////////////////////////////////////////
-  const Double_t kcarbonfiberjunctionrotphi[3]   = {   0., 120., 240.};
-  const Double_t kcarbonfiberjunctionrottheta[3] = {   0.,   0.,   0.};
-  const Double_t kcarbonfiberjunctionrotpsi[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,
-                                                                          kcarbonfiberjunctiontransx[i],
-                                                                          kcarbonfiberjunctiontransy[i],
-                                                                          kcarbonfiberjunctiontransz[i],
-                                                               new TGeoRotation(carbonfiberjunctionrotname,
-                                                                                               kcarbonfiberjunctionrotphi[i],
-                                                                                               kcarbonfiberjunctionrottheta[i],
-                                                                                               kcarbonfiberjunctionrotpsi[i]));
-    fCarbonFiberJunctionCombiTransMatrix[i] = carbonfiberjunctionlocalmatrix[i];
+  /////////////////////////////////////////////////////////////
+  // Carbon Fiber Lower Support Transformations
+  /////////////////////////////////////////////////////////////
+  TGeoTranslation* localcarbonfiberlowersupportrans[2];
+  localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
+                                                                        fgkCarbonFiberLowerSupportVolumePosition[1]
+                                                               +    fgkCarbonFiberLowerSupportVolumePosition[0],
+                                                                        0.0);
+  localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
+                                                                        fgkCarbonFiberJunctionWidth
+                                                               -    fgkCarbonFiberLowerSupportWidth
+                                                               -    fgkCarbonFiberLowerSupportVolumePosition[0]
+                                                               -    fgkCarbonFiberLowerSupportVolumePosition[1],
+                                                               -    0.5*fgkCarbonFiberLowerSupportHeight);
+   localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
+   fcarbonfiberlowersupportrans[0] = 
+                                               new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
+   fcarbonfiberlowersupportrans[1] = 
+                                               new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
+  /////////////////////////////////////////////////////////////
+  // SSD Sensor Support Transformations
+  /////////////////////////////////////////////////////////////
+  const Int_t kssdsensorsupportmatrixnumber = 3;
+  TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
+  TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
+  TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
+  for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){ 
+       localssdsensorsupportmatrix[i] = 
+                                               new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
+       localssdsensorsupportrot[i] = 
+                                               new TGeoRotation*[kssdsensorsupportmatrixnumber];
+       localssdsensorsupportrans[i] = 
+                                               new TGeoTranslation*[kssdsensorsupportmatrixnumber];
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for End Ladder Carbon Fiber Junction   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters EndLadderCarbonFiberJunction:
-  ////////////////////////////////////////////////////////
-  const Double_t kendladdercarbonfiberjunctiontransx[3] = 
-                               {  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
-               *            TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
-  const Double_t kendladdercarbonfiberjunctiontransy[3] = 
-                                                                               {  0.0, 0.0,fgkCarbonFiberTriangleLength
-               *            TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
-  const Double_t kendladdercarbonfiberjunctiontransz[3] = {  0.0,  0.0,  
-                                                  0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
-                                                          -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters EndLadderCarbonFiberJunction:
-  ////////////////////////////////////////////////////////
-  const Double_t kendladdercarbonfiberjunctionrotphi[3]   = {   0., 120., 240.};
-  const Double_t kendladdercarbonfiberjunctionrottheta[3] = {   0.,   0.,   0.};
-  const Double_t kendladdercarbonfiberjunctionrotpsi[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,
-                                                                                 kendladdercarbonfiberjunctiontransx[i],
-                                                                                 kendladdercarbonfiberjunctiontransy[i],
-                                                                                 kendladdercarbonfiberjunctiontransz[i],
-                                               new TGeoRotation(endladdercarbonfiberjunctionrotname,
-                                                                                 kendladdercarbonfiberjunctionrotphi[i],
-                                                                                   kendladdercarbonfiberjunctionrottheta[i],
-                                                                            kendladdercarbonfiberjunctionrotpsi[i]));
-    fEndLadderCarbonFiberJunctionCombiTransMatrix[i] = 
-                                                                        endladdercarbonfiberjunctionlocalmatrix[i];
+  ///////////////////////
+  // Setting Translations
+  ///////////////////////
+  localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
+                                                                         0.5*fgkSSDSensorSideSupportWidth,
+                                                                         0.0);
+  localssdsensorsupportrans[1][0] = 
+                                                new TGeoTranslation(*localssdsensorsupportrans[0][0]);
+  localssdsensorsupportrans[2][0] = 
+                                                new TGeoTranslation(*localssdsensorsupportrans[0][0]);
+  localssdsensorsupportrans[0][1] = 
+                                                new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
+                                                                               0.5*fgkSSDSensorSideSupportThickness[0],
+                                                                               0.0);
+  localssdsensorsupportrans[1][1] = 
+                                                new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
+                                                                       -   0.5*fgkSSDSensorSideSupportThickness[0]
+                                                                   -   fgkSSDModuleSensorSupportDistance,
+                                                                               0.0);
+  localssdsensorsupportrans[2][1] = 
+                                                new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
+                                                                       -    fgkSSDSensorCenterSupportPosition,
+                                                                                0.5*fgkSSDSensorCenterSupportWidth
+                                                                       -    0.5*fgkSSDModuleSensorSupportDistance,
+                                                                                fgkSSDSensorCenterSupportThickness[0]);
+  localssdsensorsupportrans[0][2] = 
+                                                new TGeoTranslation(fgkCarbonFiberTriangleLength
+                                                                       +    fgkCarbonFiberJunctionToSensorSupport,
+                                                                                fgkCarbonFiberJunctionWidth
+                                                                   -    0.5*(fgkCarbonFiberLowerSupportWidth
+                                                                       +    fgkSSDSensorCenterSupportLength
+                                                                       -    fgkSSDSensorCenterSupportThickness[0])
+                                                                       -    fgkSSDSensorCenterSupportPosition,
+                                                                            0.0);
+  localssdsensorsupportrans[1][2] = 
+                                               new TGeoTranslation(*localssdsensorsupportrans[0][2]);
+  localssdsensorsupportrans[2][2] = 
+                                               new TGeoTranslation(*localssdsensorsupportrans[0][2]);
+  ////////////////////
+  // Setting Rotations
+  ////////////////////
+  for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
+               for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
+                       localssdsensorsupportrot[i][j] = new TGeoRotation();
+  for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
+       localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
+       localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
   }
-}
-////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for Carbon fiber Assembly   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters CarbonFiberAssembly:
-  ////////////////////////////////////////////////////////
-  const Double_t kcarbonfiberassemblytransx[3] = {  0.0,  0.0,  0.0};
-  const Double_t kcarbonfiberassemblytransy[3] = 
-                                                                               {  0.5*fgkCarbonFiberJunctionWidth, 0.0, 
-                                       fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
-                          -    fgkCarbonFiberLowerSupportVolumePosition[0]
-                          -    fgkCarbonFiberLowerSupportVolumePosition[1]};
-  const Double_t kcarbonfiberassemblytransz[3] = 
-                                                 {  0.0,  0.0,-  0.5*fgkCarbonFiberLowerSupportHeight};
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters CarbonFiberAssembly:
-  ////////////////////////////////////////////////////////
-  const Double_t kcarbonfiberassemblyrotphi[3]   = {   0.,  90.,   0.};
-  const Double_t kcarbonfiberassemblyrottheta[3] = {  90.,
-                                                                                       -fgkCarbonFiberTriangleAngle,   0.};
-  const Double_t kcarbonfiberassemblyrotpsi[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,
-                                                                                  kcarbonfiberassemblytransx[i],
-                                                                                  kcarbonfiberassemblytransy[i],
-                                                                                  kcarbonfiberassemblytransz[i],
-                                                new TGeoRotation(carbonfiberassemblyrotname,
-                                                                                  kcarbonfiberassemblyrotphi[i],
-                                                                                  kcarbonfiberassemblyrottheta[i],
-                                                                                  kcarbonfiberassemblyrotpsi[i]));
-    fCarbonFiberAssemblyCombiTransMatrix[i] = carbonfiberassemblylocalmatrix[i];
+  localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
+  localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
+  localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
+  ////////////////////////////////////////
+  // SSD Sensor Support matrix 
+  ////////////////////////////////////////
+  for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
+               fssdsensorsupportmatrix[i] = new TGeoHMatrix();
+               for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
+                       localssdsensorsupportmatrix[i][j] = 
+                       new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
+                                                          *localssdsensorsupportrot[i][j]);
+                   fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
+        }
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
   /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for Cooling Tube Support   
+  // SSD Cooling Tube Support Transformations
   /////////////////////////////////////////////////////////////
-  //Translation Parameters CoolingTubeSupport:
-  ////////////////////////////////////////////////////////
+  const Int_t kcoolingtubesupportmatrixnumber = 2;
+  TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
+  TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
+  TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
                                                                                                        /fgkCoolingTubeSupportRmax);
-  const Double_t kcoolingtubesupporttransx[2] = 
-                                                 {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
+  localcoolingtubesupportrans[0] = 
+                       new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
                                                +  2.*(fgkCoolingTubeSupportLength
                                                -  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
                                                +  fgkCarbonFiberTriangleLength
-                                               -  2.0*fgkCarbonFiberJunctionLength};
-  const Double_t kcoolingtubesupporttransy[2] = {  0.0,  0.0};
-  const Double_t kcoolingtubesupporttransz[2] = {  0.0,  0.0};
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters CoolingTubeSupport:
-  ////////////////////////////////////////////////////////
-  const Double_t kcoolingsubesupportrotphi[2]   = {   0., 180.};
-  const Double_t kcoolingsubesupportrottheta[2] = {   0.,   0.};
-  const Double_t kcoolingsubesupportrotpsi[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,
-                                                          kcoolingtubesupporttransx[i],
-                                                          kcoolingtubesupporttransy[i],
-                                                          kcoolingtubesupporttransz[i],
-                                                          new TGeoRotation(coolingtubesupportrotname,
-                                                                                               kcoolingsubesupportrotphi[i],
-                                                                                               kcoolingsubesupportrottheta[i],
-                                                                                               kcoolingsubesupportrotpsi[i]));
-    fCoolingTubeSupportCombiTransMatrix[i] = coolingtubesupportlocalmatrix[i];
+                                               -  2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
+  localcoolingtubesupportrans[1] = 
+                       new TGeoTranslation(fgkCarbonFiberJunctionLength
+                                       - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
+                                       - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                                                  fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                    +  0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                    -  0.5*(fgkCarbonFiberLowerSupportWidth
+                                       +          fgkSSDSensorCenterSupportLength
+                    -      fgkSSDSensorCenterSupportThickness[0])
+                                       +  0.5*fgkSSDSensorLength,
+                                       -  0.5*fgkCoolingTubeSupportHeight);  
+  for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)     
+  localcoolingtubesupportrot[i] = new TGeoRotation();
+  localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
+  localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
+  for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
+       localcoolingtubesupportmatrix[i] = 
+               new TGeoCombiTrans(*localcoolingtubesupportrans[i],
+                                                  *localcoolingtubesupportrot[i]);
+  fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
+  fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
+                                                               (*localcoolingtubesupportmatrix[0]));
+  /////////////////////////////////////////////////////////////
+  // SSD Cooling Tube Transformations
+  /////////////////////////////////////////////////////////////
+  TGeoRotation* localcoolingtuberot = new TGeoRotation();      
+  localcoolingtuberot->SetAngles(0.,90.,0.);
+  TGeoTranslation** localcoolingtubetrans[4];
+  TVector3** localcoolingtubevect[4];
+  for(Int_t i=0; i<4; i++){
+       localcoolingtubevect[i] = new TVector3*[2];
+       localcoolingtubetrans[i] = new TGeoTranslation*[2];
+       fcoolingtubematrix[i] = new TGeoHMatrix*[2];
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for Cooling Tube  
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters CoolingTube:
-  ////////////////////////////////////////////////////////
-  const Double_t kcoolingtubetransx[2] = {  0.,  fgkCoolingTubeSeparation};
-  const Double_t kcoolingtubetransy[2] = {  fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
-  const Double_t kcoolingtubetransz[2] = {  0.0,  0.};
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters CoolingTube:
-  ////////////////////////////////////////////////////////
-  const Double_t kcoolingtuberotphi[2]   = {   0.,   0.};
-  const Double_t kcoolingtuberottheta[2] = {  90.,  90.};
-  const Double_t kcoolingtuberotpsi[2]   = {   0.,   0.};
-  ///////////////////////////////////////////////////////////
-  //Name of CombiTrans Transformation of CarbonFiberJunction:
-  ///////////////////////////////////////////////////////////
-  const char* coolingtubecombitransname[fgkCoolingTubeCombiTransNumber] = 
-                                                       {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
-  const char* coolingtuberotationname[fgkCoolingTubeCombiTransNumber] = 
-                                                               {"CoolingTubeRotation0","CoolingTubeRotation1"};
-  TGeoCombiTrans *coolingtubelocalmatrix[fgkCoolingTubeCombiTransNumber];
-  for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
-        coolingtubelocalmatrix[i] =
-                       new TGeoCombiTrans(coolingtubecombitransname[i],
-                                                          kcoolingtubetransx[i],
-                                                          kcoolingtubetransy[i],
-                                                          kcoolingtubetransz[i], 
-                                                          new TGeoRotation(coolingtuberotationname[i],
-                                                                           kcoolingtuberotphi[i],
-                                                                           kcoolingtuberottheta[i],
-                           kcoolingtuberotpsi[i]) );
-    fCoolingTubeTransMatrix[i] = coolingtubelocalmatrix[i];
+  localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+                                                 -fgkCarbonFiberTriangleLength),
+                                                 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                                                                fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                                                 +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                                                 -      0.5*(fgkCarbonFiberLowerSupportWidth
+                                                 +      fgkSSDSensorCenterSupportLength
+                                                 -      fgkSSDSensorCenterSupportThickness[0])+
+                                                        0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
+                                                 -  2.0*fgkSSDModuleStiffenerPosition[1]
+                                                 -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
+                                                 -  0.5*fgkCoolingTubeSupportWidth,
+                                                 -  0.5*fgkCoolingTubeSupportHeight);  
+  localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
+                                                       localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
+                                                 -  2.0*fgkSSDModuleStiffenerPosition[1]
+                                                 -      2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
+                                                 +  fgkCoolingTubeSupportWidth,
+                                                 localcoolingtubevect[0][0]->Z());     
+  localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
+                                                        +                               fgkCarbonFiberTriangleLength,
+                                                                                        localcoolingtubevect[0][0]->Y(),
+                                                                                        localcoolingtubevect[0][0]->Z());
+  localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
+                                                        +                               fgkCarbonFiberTriangleLength,
+                                                                                        localcoolingtubevect[0][1]->Y(),
+                                                                                        localcoolingtubevect[0][1]->Z());
+  localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+                                                 -     fgkCarbonFiberTriangleLength),
+                                                 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                                                                fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                                                 +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                                                 -      0.5*(fgkCarbonFiberLowerSupportWidth
+                                                 +      fgkSSDSensorCenterSupportLength
+                                                 -      fgkSSDSensorCenterSupportThickness[0])
+                                                 +  fgkSSDModuleStiffenerPosition[1]
+                                                 -  0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
+                                                 -  0.5*fgkCoolingTubeSupportHeight);  
+  localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
+                                                        +                               fgkCarbonFiberTriangleLength,
+                                                                                        localcoolingtubevect[2][0]->Y(),
+                                                                                        localcoolingtubevect[2][0]->Z());      
+  localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+                                                 -     fgkCarbonFiberTriangleLength),
+                                                 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                                                                fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                                                 +      0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                                                 -      0.5*(fgkCarbonFiberLowerSupportWidth
+                                                 +      fgkSSDSensorCenterSupportLength
+                                                 -      fgkSSDSensorCenterSupportThickness[0])
+                                                 +      fgkSSDSensorLength
+                                                 -      0.5*fgkSSDModuleStiffenerPosition[1],
+                                                 -  0.5*fgkCoolingTubeSupportHeight);  
+  localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
+                                                 + fgkCarbonFiberTriangleLength,
+                                                       localcoolingtubevect[3][0]->Y(),
+                                                 - 0.5*fgkCoolingTubeSupportHeight);   
+  for(Int_t i=0; i<4; i++) 
+       for(Int_t j=0; j<2; j++){
+               localcoolingtubetrans[i][j] = 
+                       new TGeoTranslation(localcoolingtubevect[i][j]->X(),
+                                                               localcoolingtubevect[i][j]->Y(),
+                                                               localcoolingtubevect[i][j]->Z());
+               fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
+                                                         *                                     (*localcoolingtuberot));
+       }
+  /////////////////////////////////////////////////////////////
+  // SSD Hybrid Components Transformations
+  /////////////////////////////////////////////////////////////
+  const Int_t khybridmatrixnumber = 3;
+  TGeoTranslation* localhybridtrans[khybridmatrixnumber];
+  localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
+                                            0.5*fgkSSDStiffenerWidth,
+                                            0.5*fgkSSDStiffenerHeight);
+  localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
+                                            fgkSSDModuleStiffenerPosition[1],0.0);
+
+  localhybridtrans[2] = new TGeoTranslation(
+                      -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
+                      -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                              fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                      +                0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                      -                0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+                      -       fgkSSDSensorCenterSupportThickness[0]),
+                      -      (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
+                      -       fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight)); 
+  fhybridmatrix = new TGeoHMatrix();
+  for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
+  /////////////////////////////////////////////////////////////
+  // SSD Cooling Block Transformations
+  /////////////////////////////////////////////////////////////
+  const Int_t kcoolingblockmatrixnumber = 4;    
+  TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
+  localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
+                            -  fgkCoolingTubeSupportRmin),0.0,
+                               0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
+  localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
+                            -  0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
+                               0.0,fgkSSDStiffenerHeight);
+  localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
+  localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
+  fcoolingblocksystematrix = new TGeoHMatrix();
+  for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
+      fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
+  /////////////////////////////////////////////////////////////
+  // SSD Stiffener Flex Transformations
+  /////////////////////////////////////////////////////////////
+  const Int_t klocalflexmatrixnumber = 4;
+  TGeoCombiTrans** localflexmatrix[fgkflexnumber];
+  for(Int_t i=0; i<fgkflexnumber; i++)    
+      localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
+  for(Int_t i=0; i<fgkflexnumber; i++)
+      for(Int_t j =0; j<klocalflexmatrixnumber; j++) 
+            localflexmatrix[i][j] = new TGeoCombiTrans();
+  Double_t ssdstiffenerseparation = fgkSSDSensorLength
+                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
+                                                                 -    fgkSSDStiffenerWidth;
+  localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
+                                        +0.5*fgkSSDStiffenerLength,
+                                         0.5*fgkSSDStiffenerWidth,
+                                        -0.5*fgkSSDStiffenerHeight
+                                        -0.5*fgkSSDFlexHeight[0]);
+  localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
+                                        +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
+                                        -0.5*fgkSSDStiffenerWidth,
+                                        -0.5*fgkSSDStiffenerHeight
+                                        -0.5*fgkSSDFlexHeight[0]);
+  TGeoRotation* localflexrot = new TGeoRotation();
+  localflexrot->SetAngles(180.,0.,0.);    
+  localflexmatrix[1][0]->SetRotation(localflexrot);
+  for(Int_t i=0; i<fgkflexnumber; i++)
+      for(Int_t j =1; j<klocalflexmatrixnumber; j++) 
+            localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
+  for(Int_t i=0; i<fgkflexnumber; i++){
+      fstiffenerflexmatrix[i] = new TGeoHMatrix();
+      for(Int_t j =0; j<klocalflexmatrixnumber; j++)   
+            fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for SSD Ladder Segment   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters LadderSegment:
-  ////////////////////////////////////////////////////////
-       const Double_t kladdersegmenttransx[fgkLadderSegmentCombiTransNumber] = {  0.,
-        -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
-                        fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
-                        fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
-        -       fgkCoolingTubeSupportRmax),
-               0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)}; 
-       const Double_t kladdersegmenttransy[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 kladdersegmenttransz[fgkLadderSegmentCombiTransNumber] = {  0.,
-        -        (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
-        -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
-                                                                                                                                                        0.,
-        -     0.5*fgkCoolingTubeSupportHeight,
-        -     0.5*fgkCoolingTubeSupportHeight};
-//////////////////////////////////////////////////
-  //Rotational Parameters LadderSegment:
-  ////////////////////////////////////////////////////////
-  const Double_t kladdersegmentrotphi[fgkLadderSegmentCombiTransNumber]   =
-                                                                                                         {   0.,   0.,- 90.,   0.,  0.};
-  const Double_t kladdersegmentrottheta[fgkLadderSegmentCombiTransNumber] = 
-                                                                                                         {   0.,   0.,   0.,  90.,  0.};
-  const Double_t kladdersegmentrotpsi[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,
-                                                                          kladdersegmenttransx[i],
-                                                                          kladdersegmenttransy[i],
-                                                                          kladdersegmenttransz[i],
-                                                                          new TGeoRotation(laddersegmentrotname,
-                                                                                                               kladdersegmentrotphi[i],
-                                                                                                               kladdersegmentrottheta[i],
-                                                                                                               kladdersegmentrotpsi[i]));
-    fLadderSegmentCombiTransMatrix[i] = laddersegmentlocalmatrix[i];
+  /////////////////////////////////////////////////////////////
+  // SSD End Flex Transformations
+  /////////////////////////////////////////////////////////////
+  TGeoRotation* localendflexrot = new TGeoRotation();
+  localendflexrot->SetAngles(0.0,90.0,0.0);
+  TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
+  Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
+                            /  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
+  Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+                            * TMath::DegToRad()*ssdflexradiusmax
+                                                              - fgkSSDFlexLength[2]-TMath::Pi()
+                                                              * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
+  Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
+                            + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
+                            +      fgkSSDFlexLength[2];
+  localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
+                              0.5*fgkSSDFlexWidth[0],
+                              2.*fgkSSDStiffenerHeight
+                            + 0.5*fgkSSDFlexHeight[0]);      
+  localendflexmatrix->SetRotation(localendflexrot);
+  for(Int_t i=0; i<fgkflexnumber; i++) 
+      fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
+  /////////////////////////////////////////////////////////////
+  // End Ladder Carbon Fiber Junction
+  /////////////////////////////////////////////////////////////
+  TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
+  TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];    
+  TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];    
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+      localendladdercarbonfiberjunctionmatrix[i] 
+            = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
+      localendladdercarbonfiberjunctionrot[i] 
+            = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
+      localendladdercarbonfiberjunctiontrans[i] 
+            = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
+      fendladdercarbonfiberjunctionmatrix[i]
+            = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
-  /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for SSD End Ladder Segment   
-  /////////////////////////////////////////////////////////////
-  //Translation Parameters EndLadderSegment:
-  ////////////////////////////////////////////////////////
-  const Double_t kendladdersegmenttransx[fgkEndLadderSegmentCombiTransNumber] =
-            {0.0,
-                                                                                         0.0,
-          -  0.25*(fgkSSDMountingBlockLength[0]
-                              +         fgkSSDMountingBlockLength[1])
-          +  0.5*fgkCarbonFiberTriangleLength,
-                                                                                         0.0}; 
-  const Double_t kendladdersegmenttransy[fgkEndLadderSegmentCombiTransNumber] = 
-                                                        {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
-            i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
-                        fgkEndLadderMountingBlockPosition[i],
-                                                  (1-i)*(fgkEndLadderMountingBlockPosition[i]
-                                                                                +  0.5*fgkSSDMountingBlockWidth)}; 
-  const Double_t kendladdersegmenttransz[fgkEndLadderSegmentCombiTransNumber] = 
-            {0.0,
-                                                                                         0.0,
-                                                                               -  fgkSSDMountingBlockHeight[1]
-                                                                               +  0.5*fgkSSDMountingBlockHeight[0],
-          -  0.5*fgkCarbonFiberLowerSupportHeight}; 
-  ////////////////////////////////////////////////////////
-  //Rotational Parameters EndLadderSegment:
-  ////////////////////////////////////////////////////////  
-  const Double_t kendladdersegmentrotphi[fgkEndLadderSegmentCombiTransNumber] =  
-            {   0.,  90.,   0.,   0.};
-  const Double_t kendladdersegmentrottheta[fgkEndLadderSegmentCombiTransNumber] = 
-            {  90.,-fgkCarbonFiberTriangleAngle, 0.,   0.};
-  const Double_t kendladdersegmentrotpsi[fgkEndLadderSegmentCombiTransNumber] = 
-            {   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,
-                                                                  kendladdersegmenttransx[i],
-                                                                  kendladdersegmenttransy[i],
-                                                                  kendladdersegmenttransz[i],
-                                                                  new TGeoRotation(endladdersegmentrotname,
-                                                                                                       kendladdersegmentrotphi[i],
-                                                                                                       kendladdersegmentrottheta[i],
-                                                                                                       kendladdersegmentrotpsi[i]));
-    fEndLadderSegmentCombiTransMatrix[i] = endladdersegmentlocalmatrix[i];
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)    
+      for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+            localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
+            localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
+      }
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)     
+      for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
+          localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+      localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
+                              0.0,0.0);
+      localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
+               *                     CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
+               *                     SinD(fgkCarbonFiberTriangleAngle),
+                        0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
+  -                          fgkEndLadderCarbonFiberUpperJunctionLength[i]));
+  }
+  TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
+  TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
+  TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+      localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
+      localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
+      localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
+      localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
+            0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
+      localendladdercarbonfiberjunctionglobalmatrix[i] = 
+            new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
+                               *localendladdercarbonfiberjunctionglobalrot[i]);
+  }
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)    
+      for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+            localendladdercarbonfiberjunctionmatrix[i][j] = 
+                  new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
+                                     *localendladdercarbonfiberjunctionrot[i][j]);
+           fendladdercarbonfiberjunctionmatrix[i][j] =
+            new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
+            *               (*localendladdercarbonfiberjunctionmatrix[i][j])); 
+      }  
+  /////////////////////////////////////////////////////////////
+  // End Ladder Carbon Fiber Support
+  /////////////////////////////////////////////////////////////
+  TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
+  for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
+      localendladdercarbonfibertrans[i] = new TGeoTranslation();
+      localendladdercarbonfibertrans[i]->SetTranslation(0.0,
+            i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
+      fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
+  }
+  for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
+      for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
+            fendladdercarbonfibermatrix[i][j] = 
+            new TGeoHMatrix((*localendladdercarbonfibertrans[i])
+            *(*fcarbonfibersupportmatrix[j]));
+  /////////////////////////////////////////////////////////////
+  // End Ladder SSD Mounting Block
+  /////////////////////////////////////////////////////////////
+  for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+      fendladdermountingblocktrans[i] = 
+            new TGeoTranslation(-  0.25*(fgkSSDMountingBlockLength[0]
+                                +       fgkSSDMountingBlockLength[1])
+                                +  0.5*fgkCarbonFiberTriangleLength,
+                                fgkEndLadderMountingBlockPosition[i],
+                                -  fgkSSDMountingBlockHeight[1]
+                                +  0.5*fgkSSDMountingBlockHeight[0]);
+  /////////////////////////////////////////////////////////////
+  // End Ladder Carbon Fiber Lower Support
+  /////////////////////////////////////////////////////////////
+  for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
+      fendladderlowersupptrans[i] = 
+            new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
+                        +  0.5*fgkSSDMountingBlockWidth),
+                        -  0.5*fgkCarbonFiberLowerSupportHeight);
+  fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
+                                                                        fgkCarbonFiberLowerSupportVolumePosition[1]
+                                                               +    fgkCarbonFiberLowerSupportVolumePosition[0],
+                                                                        0.0);
+  fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
+ /////////////////////////////////////////////////////////////
+  // Matrix for positioning Ladder into mother volume
+  /////////////////////////////////////////////////////////////
+  TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
+  for(Int_t i=0; i<fgkladdernumber; i++) 
+       ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
+  TGeoRotation* localladdermotherrot = new TGeoRotation();
+  localladdermotherrot->SetAngles(0.,90.,0.);  
+  TGeoTranslation* localladdermothertrans[fgkladdernumber];
+  TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
+  for(Int_t i=0; i<fgkladdernumber; i++){
+       localladdermothertrans[i] = new TGeoTranslation(0.,
+                                                         - fgkEndLadderCarbonFiberLowerJunctionLength[1]
+                                                         + fgkEndLadderCarbonFiberLowerJunctionLength[0]
+                                                         + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
+                                                         * fgkCarbonFiberJunctionWidth,0.);
+       localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
+                                                                                                               *localladdermotherrot);
+       ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
+       ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
   }
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
   /////////////////////////////////////////////////////////////
-  // Method generating CombiTrans Matrix for SSD Ladder Cable   
+  // Ladder Cables Matrices
   /////////////////////////////////////////////////////////////
-  // 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());
+                                                 *   SinD(2.*fgkSSDFlexAngle)
+                                                 *       CosD(2.*fgkSSDFlexAngle);
   ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
                                                  -     ssdladdercabletransx[0]
-                                                 /     TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
-                                                 *     TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());                                          
+                                                 /     SinD(2.*fgkSSDFlexAngle))
+                                                 *     CosD(fgkSSDFlexAngle);                                          
   ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
                                                  *       TMath::DegToRad()*ssdflexradiusmax
                                                  -     fgkSSDFlexLength[2]-TMath::Pi()
                                                  *       fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
                                                  -       fgkSSDLadderCableWidth)
-                                                 *       TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
+                                                 *       CosD(2.*fgkSSDFlexAngle);
   Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
-                                                 *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
+                                                 *     TanD(2.*fgkSSDFlexAngle),
                                                        ssdladdercabletransx[1]
-                                                 *     TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
+                                                 *     TanD(fgkSSDFlexAngle),
                                                        ssdladdercabletransx[2]
-                                                 *     TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};      
+                                                 *     TanD(2.*fgkSSDFlexAngle)};      
   TGeoRotation* localladdercablerot[3];        
-  localladdercablerot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
-  localladdercablerot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
-  localladdercablerot[2] = new TGeoRotation("LocalLadderCableRot2");
+  for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
+  localladdercablerot[0]->SetAngles(90.,0.,0.);
+  localladdercablerot[1]->SetAngles(90.,60.,-90.);
   localladdercablerot[2]->SetRotation((*localladdercablerot[1])
                                                 *                        (*localladdercablerot[0]));
   ////////////////////////////////////////////
@@ -904,11 +1023,27 @@ void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
   localladdercablecombitransmatrix[0][0]  =
                                                new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
                                                0.,0.,NULL);
-  localladdercablecombitransmatrix[0][1] = fLadderSegmentCombiTransMatrix[1];
+  localladdercablecombitransmatrix[0][1] = 
+       new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
+                                          - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                                                fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                                          + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                                          - 0.5*(fgkCarbonFiberLowerSupportWidth
+                                          + fgkSSDSensorCenterSupportLength
+                                          - fgkSSDSensorCenterSupportThickness[0]),
+                                          - (fgkSSDModuleCoolingBlockToSensor
+                                          + 0.5*fgkCoolingTubeSupportHeight
+                                          - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
+                                          - fgkSSDChipHeight),NULL);
   localladdercablecombitransmatrix[0][2] = 
                                                new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
                                                                                   fgkSSDModuleStiffenerPosition[1],0.,0);
-  localladdercablecombitransmatrix[0][3] = fSSDModuleCombiTransMatrix[6];
+  localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
+                                       0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+                                  +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+                                  fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+                                        - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
+                                                                                               new TGeoRotation("",180.,0.,0.));
   localladdercablecombitransmatrix[0][4] = 
                                                new TGeoCombiTrans(-ssdladdercabletransx[0]
                                                -     ssdladdercabletransx[1]-ssdladdercabletransx[2]
@@ -921,1604 +1056,472 @@ void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
   ///////////////////////////////////////////
   // Rigth Side Ladder Cables Transformations
   ///////////////////////////////////////////
+  TGeoCombiTrans* localladdercablessdmodulematrix = 
+       new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
+                                                                 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+                                                                        fgkSSDStiffenerWidth,
+                                                                 - 0.5*fgkSSDFlexHeight[0],NULL);
   for(Int_t i=0; i<klocalladdercombitransnumber; i++)
    localladdercablecombitransmatrix[1][i] = 
-                       (i!=3 ? localladdercablecombitransmatrix[0][i]:
-                                       fSSDModuleCombiTransMatrix[3]);         
+                       (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
+                                       new TGeoCombiTrans(*localladdercablessdmodulematrix));  
   ///////////////////////////////////////////
-  // Setting LadderCableCombiTransMatrix
+  // Setting LadderCableHMatrix
   ///////////////////////////////////////////
-  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[klocalladdersidecablesnumber];
-  TGeoRotation* laddercablerot;
-  TGeoTranslation* laddercabletrans;
-  for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
-        localladdercablehmatrix[i] = new TGeoHMatrix();
-        for(Int_t j=0; j<klocalladdercombitransnumber; j++){
-                  localladdercablehmatrix[i]->MultiplyLeft(
-                  localladdercablecombitransmatrix[i][klocalladdercombitransnumber-j-1]);
-        }
-        laddercablerot = new TGeoRotation();
-        laddercablerot->SetMatrix(localladdercablehmatrix[i]->GetRotationMatrix());
-  laddercabletrans = new TGeoTranslation();
-  Double_t* laddercabletransvector = localladdercablehmatrix[i]->GetTranslation();
-  laddercabletrans->SetTranslation(laddercabletransvector[0],
+  Int_t beamaxistrans[2][3];
+  beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2; 
+  beamaxistrans[0][1] = beamaxistrans[0][0]+1;
+  beamaxistrans[0][2] = beamaxistrans[0][0]-1;
+  beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
+  beamaxistrans[1][1] = beamaxistrans[1][0]+1;
+  beamaxistrans[1][2] = beamaxistrans[1][0];
+  TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
+  TGeoRotation* laddercablerot = new TGeoRotation();
+  TGeoTranslation* laddercabletrans = new TGeoTranslation();
+  TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
+  Double_t* laddercabletransvector;    
+  for(Int_t i=0; i<fgkladdercablesnumber; i++){ 
+       localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
+       fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
+  }
+  for(Int_t i=0; i<fgkladdercablesnumber; i++){
+       for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
+               localladdercablehmatrix[i][j] = new TGeoHMatrix();
+               for(Int_t k=0; k<klocalladdercombitransnumber; k++){
+                       localladdercablehmatrix[i][j]->MultiplyLeft(
+                       localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
+        }
+               laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
+               laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
+               laddercabletrans->SetTranslation(laddercabletransvector[0],
                                                                         laddercabletransvector[1]
-                                       +                (i==0 ? beamaxistrans[0] : 0.)
+                                       +                (j==0 ? beamaxistrans[i][0] : 0.)
                                        *                                fgkCarbonFiberJunctionWidth,
-                                                                        laddercabletransvector[2]);     
-        fLadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*laddercabletrans,
-                                                                                                  *laddercablerot);
-       } 
-       fLadderCableCombiTransMatrix[2] = 
-                                       AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[1],0.,
-                                       beamaxistrans[1]*fgkCarbonFiberJunctionWidth,0.);
-       fLadderCableCombiTransMatrix[3] = 
-                                       AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[0],0.,
-                                       beamaxistrans[2]*fgkCarbonFiberJunctionWidth,0.);
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length, 
-                                                       Double_t height,Double_t width,Double_t* thickness){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Sensor Support Shape   
-  /////////////////////////////////////////////////////////////
-  const Int_t kvertexnumber = 4;
-  const Int_t kshapesnumber = 2;
-  Double_t shapewidth[2] = {width,width};
-  TVector3** vertexposition[kshapesnumber];
-  for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] = 
-                                                                                                       new TVector3*[kvertexnumber];
-  //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[kshapesnumber] = 
-                                                       {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
-  TGeoArb8* lSSDSensorSupportShape[kshapesnumber];
-  for(Int_t i = 0; i< kshapesnumber; i++) lSSDSensorSupportShape[i] = 
-                                          GetArbShape(vertexposition[i],shapewidth,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",
-                                                       lSSDSensorSupportShape[0],fSSDSensorSupportMedium),1,
-                                                       ssdsensorsupportshapetrans);
-  ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
-                                                       lSSDSensorSupportShape[1],fSSDSensorSupportMedium),1,
-                                                       ssdsensorsupportcombitrans);
-  return ssdsensorsupportcompvolume;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Sensor Support    
-  /////////////////////////////////////////////////////////////
-  TGeoVolume* ssdsensorsupport;
-  Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
-                                                                                  fgkSSDSensorSideSupportThickness[1]};
-  VolumeKind == 0 ? ssdsensorsupport = GetSSDSensorSupportShape(
-                                                               fgkSSDSensorSideSupportLength,
-                                                               fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
-                                                               fgkSSDSensorSideSupportWidth,
-                                                               sidesupporthickness) :
-    ssdsensorsupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
-                                                       fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
-                                                           fgkSSDSensorCenterSupportWidth,
-                                                           sidesupporthickness);
-  return ssdsensorsupport;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Sensor Support Assembly   
-  /////////////////////////////////////////////////////////////
-  TGeoVolume* ssdsensorsupportassembly = 
-                                                        new TGeoVolumeAssembly("SSDSensorSupportAssembly");
-  const Int_t kvolumenumber = 2;
-  TGeoVolume* ssdsensorsupport[kvolumenumber];
-  for(Int_t i=0; i<kvolumenumber; 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,fSSDSensorSupportCombiTransMatrix[i]);
-  return ssdsensorsupportassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Sensor Module    
-  /////////////////////////////////////////////////////////////
-  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)
-                                               *                                 (*fSSDModuleCombiTransMatrix[i]));
-       ssdmodule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? ssdmodulevolume[3] : 
-                                                 ssdmodulevolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
-                                                 ssdmodulehmatrix[i]);
-  }
-  return ssdmodule;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Sensor  
-  /////////////////////////////////////////////////////////////
-  Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
-  Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
-  TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
-                                                0.5*ssdsensitivelength,
-                                                0.5*ssdsensitivewidth,
-                                                0.5*fgkSSDSensorHeight);
-  TGeoVolume* ssdsensorsensitive = 
-      new TGeoVolume(fgkSSDSensitiveVolName,ssdsensorsensitiveshape,fSSDSensorMedium);
-  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*ssdsensitivewidth,
-                                                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],
-                     fSSDSensorMedium);
-      ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
+                                                                        laddercabletransvector[2]);
+               laddercablecombitrans->SetRotation(*laddercablerot);
+               laddercablecombitrans->SetTranslation(*laddercabletrans);       
+               fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
+       }
+    fladdercablematrix[i][2] = 
+                                       AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
+                                       beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
+       fladdercablematrix[i][3] = 
+                                       AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
+                                       beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
   }
-  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{
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Chip Assembly    
-  /////////////////////////////////////////////////////////////
-  const Int_t kssdchiprownumber = 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],fSSDChipMedium);
-  ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
-                                                                 fSSDChipGlueMedium);
-  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<kssdchiprownumber; 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(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Stiffener Assembly    
-  /////////////////////////////////////////////////////////////
-  const Int_t kssdstiffenernumber = 2;
-  Double_t ssdstiffenerseparation = fgkSSDSensorLength
-                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
-                                                                 -    fgkSSDStiffenerWidth;
-  TGeoVolume* ssdstiffener = new TGeoVolumeAssembly("SSDStiffener");
-////////////////////////////
-// Stiffener Volumes
-///////////////////////////
-  const Int_t kstiffenerboxnumber = 6;
-  TGeoBBox* ssdstiffenerboxshapes[kstiffenerboxnumber];
-  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[kstiffenerboxnumber];
-  char ssdtiffenerboxname[30];
-  for(Int_t i=0; i<kstiffenerboxnumber; i++){ 
-        sprintf(ssdtiffenerboxname,"SSDStiffenerBox%i",i+1);
-    ssdstiffenerbox[i] = new TGeoVolume(ssdtiffenerboxname,ssdstiffenerboxshapes[i],
-                                                                         fSSDStiffenerMedium);
-       ssdstiffenerbox[i]->SetLineColor(fColorStiffener);
+  for(Int_t i=0; i<fgkladdercablesnumber; i++)
+       for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
+               fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
+  ///////////////////////////////////////////
+  // Setting Ladder HMatrix
+  ///////////////////////////////////////////
+  Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
+                                                                                               fgkSSDLay6SensorsNumber};
+  for(Int_t i=0; i<fgkladdernumber; i++){
+       fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
+       for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
+               fladdermatrix[i][j] = new TGeoHMatrix();
+               fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+               fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
+               fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
+       }
   }
-////////////////////////////
-// Connector 
-///////////////////////////
-  TGeoBBox* ssdconnectorshape =  new TGeoBBox("SSDConnectorShape",
-                                                                                        0.5*fgkSSDConnectorLength,
-                                                                                        0.5*fgkSSDConnectorWidth,
-                                                                                        0.5*fgkSSDConnectorHeight);
-  TGeoVolume* ssdconnector    = new TGeoVolume("SSDConnector",ssdconnectorshape,
-                                                                                               fSSDStiffenerConnectorMedium); 
-  ssdconnector->SetLineColor(fColorAl);
-  const Int_t kssdconnectornumber = 2;
-  TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
-  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<kssdconnectornumber; i++)
-                       ssdstiffener->AddNode(ssdconnector,i+1,ssdconnectortrans[i]);   
-//////////////////////////////////////
-// TGeoTranslation for Stiffener Boxes
-//////////////////////////////////////
-  TGeoTranslation* ssdstiffenerboxtrans[kstiffenerboxnumber];
-  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<kstiffenerboxnumber; i++) 
-               ssdstiffener->AddNode(ssdstiffenerbox[i],1,ssdstiffenerboxtrans[i]);    
-  TGeoCombiTrans* ssdstiffenercombitrans[kssdstiffenernumber];
-  char ssdstiffenercombitransname[30];
-    for(Int_t i=0; i<kssdstiffenernumber; i++){ 
-       sprintf(ssdstiffenercombitransname,"SSDStiffenerCombiTrans%i",i+1);
-    ssdstiffenercombitrans[i] = new TGeoCombiTrans(ssdstiffenercombitransname,
-                       0.,i*ssdstiffenerseparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
+  ///////////////////////////////////////////
+  // Setting SSD Sensor Matrix 
+  ///////////////////////////////////////////
+  TGeoCombiTrans* localssdsensorcombitrans[2];
+  TGeoRotation* localssdsensorrot = new TGeoRotation();        
+  localssdsensorrot->SetAngles(0.,90.,0.);     
+  TGeoTranslation* localssdsensortrans[2];
+  for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
+  localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
+                                         -             (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                              fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                      +                0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                      -                0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+                      -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+                                                       0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
+                                         -             fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
+                                         -             fgkSSDSensorSideSupportHeight[0]));
+  localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
+                                         -        (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+                              fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+                      +                0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+                      -                0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+                      -       fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+                                                   0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
+                                                       -fgkSSDModuleCoolingBlockToSensor);
+  for(Int_t i=0; i<2; i++) 
+       localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
+                                                                                                        *localssdsensorrot);   
+    for(Int_t i=0; i<fgkladdernumber; i++){
+       fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
+       for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
+               switch(i){
+                       case 0: //Ladder of Layer5  
+                       fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
+                                                                  * ((j%2==0 ? *localssdsensorcombitrans[0] :
+                                                                                               *localssdsensorcombitrans[1])));
+                       break;
+                       case 1: //Ladder of Layer6 
+                       fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
+                                                                  * ((j%2==0 ? *localssdsensorcombitrans[1] :
+                                                                                               *localssdsensorcombitrans[0])));
+               break;
+               }
+         }
+  }    
+  //////////////////////////
+  // Setting SSD End Ladder  
+  //////////////////////////
+  for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
+  for(Int_t i=0; i<2; i++){
+       fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
+       fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+       fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
+       fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
+       fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
+       fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+       fendladdersegmentmatrix[1][i]->RotateZ(180.0);
+       fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
+   }
+  /////////////////////////////////////////////////////
+  // Setting the CombiTransformation to pass ITS center 
+  /////////////////////////////////////////////////////
+  Double_t itscentertransz[fgklayernumber];
+  itscentertransz[0] = fgkSSDLay5LadderLength
+                                        - fgkLay5CenterITSPosition;
+  itscentertransz[1] = fgkSSDLay6LadderLength
+                                        - fgkLay6CenterITSPosition;
+  Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
+                                                  + 0.5*fgkCoolingTubeSupportHeight;
+  TGeoRotation* itscenterrot[3];
+  for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
+  itscenterrot[0]->SetAngles(90.,180.,-90.);
+  itscenterrot[1]->SetAngles(0.,90.,0.);
+  itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
+  TGeoCombiTrans* itscentercombitrans[fgklayernumber];
+  for(Int_t i=0; i<fgklayernumber; i++) 
+       itscentercombitrans[i] = new TGeoCombiTrans(0.,
+                                                        itssensortransy,
+                                                        fgkEndLadderCarbonFiberLowerJunctionLength[1]
+                                                  - itscentertransz[i],itscenterrot[2]);
+  TGeoRotation** locallayerrot[fgklayernumber];
+  TGeoTranslation** locallayertrans[fgklayernumber];   
+  TGeoCombiTrans** locallayercombitrans[fgklayernumber];
+  TGeoTranslation* localbeamaxistrans[fgklayernumber];
+  localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
+                                        - fgkLay5CenterITSPosition);
+  localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
+                                        - fgkLay6CenterITSPosition);
+  const Int_t kssdlayladdernumber[fgklayernumber] = 
+                       {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
+  for(Int_t i=0; i<fgklayernumber; i++){
+    locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
+    locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
+       locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
+       flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
   }
-////////////////////////////
-// Capacitor 0603-2200 nF
-///////////////////////////
-  const Int_t knapacitor0603number = 5;
-  TGeoBBox* capacitor0603shape =  new TGeoBBox("Capacitor0603Shape",
-                                                                                        0.5*fgkSSDCapacitor0603Length,
-                                                                                        0.5*fgkSSDCapacitor0603Width,
-                                                                                        0.5*fgkSSDCapacitor0603Height);
-  TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
-                                             fSSDStiffener0603CapacitorMedium); 
-  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,
-                                             fSSDStiffener1812CapacitorMedium); 
-  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,
-                                             fSSDStiffenerHybridWireMedium); 
-  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<kssdstiffenernumber; i++) {
-       ssdstiffenerassembly->AddNode(ssdstiffener,i+1,ssdstiffenercombitrans[i]);
-       for(Int_t j=1; j<knapacitor0603number+1; j++){
-    ssdstiffenerassembly->AddNode(capacitor0603,knapacitor0603number*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)));
+  Double_t layerladderangleposition[fgklayernumber] = 
+               {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
+  Double_t layerradius = 0.;
+  for(Int_t i=0; i<fgklayernumber; i++){       
+       for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+               switch(i){
+                       case 0: //Ladder of Layer5  
+                       layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
+                       break;
+                       case 1: //Ladder of Layer6 
+                       layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
+               break;
+               }
+               locallayerrot[i][j] = new TGeoRotation();
+               locallayertrans[i][j] = new TGeoTranslation();
+               locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
+               locallayertrans[i][j]->SetTranslation(layerradius 
+                                                         *     CosD(90.0+j*layerladderangleposition[i]),
+                                                           layerradius 
+                                                         * SinD(90.0+j*layerladderangleposition[i]),0.);
+               locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
+                                                                        *locallayerrot[i][j]);
+               flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
+               flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
+               flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
        }
-       if(i==1) ssdstiffenerassembly->AddNode(capacitor1812,1,capacitor1812trans);
-}
-  return ssdstiffenerassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, 
-                                                                                                                                       char* side){
+  }
   /////////////////////////////////////////////////////////////
-  // Method generating SSD Chip Cables    
+  // Deallocating memory
   /////////////////////////////////////////////////////////////
-  const Int_t kssdchipcableslaynumber = 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*kssdchipcableslaynumber] = 
-                                         {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
-                                          "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
-  char* ssdchipcablestubesegshapename[2*kssdchipcableslaynumber] = 
-                         {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
-                          "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
-  TGeoBBox** ssdchipcablesboxshape[kssdchipcableslaynumber];
-  TGeoTubeSeg** ssdchipcablestubesegshape[kssdchipcableslaynumber];
-  for(Int_t i=0; i<kssdchipcableslaynumber; 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.);
+  for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
+       delete carbonfiberot[i];
+       delete localcarbonfibersupportmatrix[i];
   }
-  //////////////////////////
-  //Box under Chip
-  //////////////////////////
-  char ssdunderchipcablesboxshapename[30];
-  char ssdunderchipcablesboxname[30];  
-  char ssdunderchipcablesboxtransname[30];     
-  TGeoBBox* ssdunderchipcablesboxshape[kssdchipcableslaynumber];
-  TGeoVolume* ssdunderchipcablesbox[kssdchipcableslaynumber]; 
-  TGeoTranslation* ssdunderchipcablesboxtrans[kssdchipcableslaynumber];
-  for(Int_t i=0; i<kssdchipcableslaynumber; 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?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));           
-        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]);
+  for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
+     for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
+       delete localcarbonfiberjunctionmatrix[i][j];
+          delete localcarbonfiberjunctionrot[i][j];
+          delete localcarbonfiberjunctiontrans[i][j];
+          }
+       delete [] localcarbonfiberjunctionmatrix[i];
+       delete [] localcarbonfiberjunctionrot[i];
+       delete [] localcarbonfiberjunctiontrans[i];
   }
-  //////////////////
-  //Trapezoid Shapes
-  //////////////////
-  const Int_t kssdchipcablesvertexnumber = 2;
-  const Int_t kssdchipcablestrapezoidnumber = 2;
-  TVector3** ssdchipcablestrapezoidvertex[kssdchipcablesvertexnumber];
-  for(Int_t i = 0; i< kssdchipcablestrapezoidnumber; i++) 
-        ssdchipcablestrapezoidvertex[i] = new TVector3*[kssdchipcablesvertexnumber];
-  //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[kssdchipcablestrapezoidnumber] = 
-                 {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
-  char* ssdchipcablestrapezoidshapename[kssdchipcablestrapezoidnumber] = 
-                 {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
-  char* ssdchipcablestrapezoidboxname[kssdchipcablestrapezoidnumber] = 
-                 {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
-  char* ssdhipcablestrapezoidname[kssdchipcablestrapezoidnumber] = 
-                 {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
-  char* ssdchipcablestrapezoidassemblyname[kssdchipcablestrapezoidnumber] = 
-                 {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
-  //Setting the Shapes
-  TGeoBBox* ssdchipcablestrapezoidboxshape[kssdchipcablestrapezoidnumber]; 
-  TGeoArb8* ssdchipcablestrapezoidshape[kssdchipcablestrapezoidnumber];
-  //Setting the Volumes
-  TGeoVolume* ssdchipcablestrapezoidbox[kssdchipcablestrapezoidnumber];
-  TGeoVolume* ssdchipcablestrapezoid[kssdchipcablestrapezoidnumber];
-  TGeoVolume* ssdchipcablestrapezoidassembly[kssdchipcablestrapezoidnumber]; 
-  Double_t ssdchipcablestrapezoidwidth[kssdchipcablesvertexnumber] = 
-   {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
-  for(Int_t i=0; i<kssdchipcablestrapezoidnumber; 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?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
-    ssdchipcablestrapezoid[i] = new TGeoVolume(ssdhipcablestrapezoidname[i],
-                                                                                          ssdchipcablestrapezoidshape[i],
-                                                                                          (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
-    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.));
+  for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++) 
+          delete localcarbonfiberlowersupportrans[i];
+  for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
+     for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
+       delete localssdsensorsupportmatrix[i][j];
+          delete localssdsensorsupportrot[i][j];
+          delete localssdsensorsupportrans[i][j];
+          }
+       delete [] localssdsensorsupportmatrix[i];
+       delete [] localssdsensorsupportrot[i];
+       delete [] localssdsensorsupportrans[i];
   }
-  /////////////////////////////
-  //Box and Tube Seg CombiTrans
-  /////////////////////////////
-  TGeoTranslation* ssdchipcablesboxtrans[2*kssdchipcableslaynumber];
-  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*(kssdchipcableslaynumber+1)];    
-//  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[kssdchipcableslaynumber];
-  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*kssdchipcableslaynumber] = 
-                                                        {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
-                                                         "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
-  char* ssdchiprightcablestubesegname[2*kssdchipcableslaynumber] = 
-                         {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
-                          "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
-  char* ssdchipLeftcablestubesegname[2*kssdchipcableslaynumber] = 
-                         {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
-                          "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
-  char* ssdchipcableslayassemblyname[kssdchipcableslaynumber] = 
-                         {"SSDChipCablesLay1","SSDChipCablesLay2"};
-  TGeoVolume** ssdchipcablesbox[kssdchipcableslaynumber];
-  TGeoVolume** ssdchipcablestubeseg[kssdchipcableslaynumber];
-  TGeoVolume* ssdchipcableslayassembly[kssdchipcableslaynumber];
-  for(Int_t i=0; i<kssdchipcableslaynumber; i++){
-    TGeoMedium* ssdchipcableslaymed = 
-            (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
-    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]);
+  for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
+       delete localcoolingtubesupportmatrix[i];
+       delete localcoolingtubesupportrot[i];
+       delete localcoolingtubesupportrans[i];
+  }
+  for(Int_t i=0; i<4; i++){
+       for(Int_t j=0; j<2; j++){
+               delete localcoolingtubevect[i][j];
+               delete localcoolingtubetrans[i][j];
+       }
+       delete [] localcoolingtubevect[i];
+       delete [] localcoolingtubetrans[i];
+  }
+ for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
+ for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
+ for(Int_t i=0; i<fgkflexnumber; i++){
+      for(Int_t j=1; j<klocalflexmatrixnumber; j++) 
+            delete localflexmatrix[i][j];
+      delete [] localflexmatrix[i];
+ }
+ delete localflexrot;
+ delete localendflexrot;
+ delete localendflexmatrix;
+ for(Int_t i=0; i<fgkladdernumber; i++){ 
+       delete localladdermothertrans[i];
+       delete localladdermothercombitrans[i];
+  }
+ delete localladdermotherrot;
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){    
+      for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+            delete localendladdercarbonfiberjunctionmatrix[i][j];
+            delete localendladdercarbonfiberjunctionrot[i][j];
+            delete localendladdercarbonfiberjunctiontrans[i][j];
+      }
+      delete [] localendladdercarbonfiberjunctionmatrix[i];
+      delete [] localendladdercarbonfiberjunctionrot[i];
+      delete [] localendladdercarbonfiberjunctiontrans[i];
+      delete localendladdercarbonfiberjunctionglobalrot[i];
+      delete localendladdercarbonfiberjunctionglobaltrans[i];
+      delete localendladdercarbonfiberjunctionglobalmatrix[i];
+ }
+ for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
+      delete localendladdercarbonfibertrans[i];
+  for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
+  for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
+       for(Int_t j=0; j<klocalladdercombitransnumber; j++)
+               delete localladdercablecombitransmatrix[i][j];
+               delete []localladdercablecombitransmatrix[i];
+  }
+  for(Int_t i=0; i<fgkladdercablesnumber; i++){
+       for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
+               delete localladdercablehmatrix[i][j];
+       delete []localladdercablehmatrix[i];
+  }
+  delete laddercablerot;
+  delete laddercabletrans;
+  delete laddercablecombitrans;
+  delete localladdercablessdmodulematrix;
+  delete localssdsensorrot;    
+  for(Int_t i=0; i<2; i++){
+       delete localssdsensortrans[i];
+       delete localssdsensorcombitrans[i];
+  }
+  for(Int_t i=0; i<fgklayernumber; i++){
+       for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+               delete locallayerrot[i][j];
+               delete locallayertrans[i][j];
+               delete locallayercombitrans[i][j];
     }
-    ssdchipcableslayassembly[i]->AddNode(ssdchipcablestrapezoidassembly[i],1,
-                                                                                ssdchipcablestrapezoidcombitrans[i]);
-  }
-  TGeoCombiTrans* ssdchipcablescombitrans[kssdchipcableslaynumber];
-  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<kssdchipcableslaynumber; i++){ 
-               ssdchipcablesassembly->AddNode(ssdchipcableslayassembly[i],1,
-                                                                                                       ssdchipcablescombitrans[i]);
-               ssdchipcablesassembly->AddNode(ssdunderchipcablesbox[i],1,ssdunderchipcablesboxtrans[i]);
-  }
-  return ssdchipcablesassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Chip Cables Assembly    
-  /////////////////////////////////////////////////////////////
-  const Int_t kchipcablesnumber = 2;
-  Double_t chipcablestransvector = fgkSSDSensorLength
-                                                                - 2.*fgkSSDModuleStiffenerPosition[1]
-                                                                - 2.*(fgkSSDStiffenerWidth
-                                                                - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
-  char* ssdchipcablesname[kchipcablesnumber] = {"Right","Left"};
-  TGeoVolume* ssdchipcables[kchipcablesnumber];  
-  TGeoVolume* ssdchipcablesassembly = 
-                                        new TGeoVolumeAssembly("SSDChipCablesAssembly");
-  for(Int_t i=0; i<kchipcablesnumber; i++) ssdchipcables[i] = 
-                                        GetSSDChipCables(SSDChipCablesHeigth,ssdchipcablesname[i]);
-  for(Int_t i=0; i<kchipcablesnumber; 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;
+       delete [] locallayerrot[i];
+       delete [] locallayertrans[i];
+       delete [] locallayercombitrans[i];
+       delete localbeamaxistrans[i];
+  }
+  for(Int_t i=0; i<3; i++) delete itscenterrot[i];
+  for(Int_t i=0; i<fgkladdernumber; i++){
+       for(Int_t j=0; j<fgkladdernumber; j++)
+               delete ladderglobalmatrix[i][j];
+       delete [] ladderglobalmatrix[i];
+  }
+  /////////////////////////////////////////////////////////////
+  fTransformationMatrices = kTRUE;     
 }
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t ssdflexradius, Double_t SSDFlexHeigth){
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::CreateBasicObjects(){
+  /////////////////////////////////////////////////////////////  
+  // Method generating the Objects of SSD Geometry    
   /////////////////////////////////////////////////////////////
-  // Method generating SSD Flex    
+  // SSD Sensor
+  ///////////////////////////////////
+  SetSSDSensor();
+  /////////////////////////////////////////////////////////////  
+  // Carbon Fiber Support    
+  /////////////////////////////////////////////////////////////  
+  TList* carbonfibersupportlist = GetCarbonFiberSupportList();  
+  for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++) 
+      fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
   /////////////////////////////////////////////////////////////
-  const Int_t kssdflexvolumenumber = 3;
-  TGeoVolume* ssdflexvolume[kssdflexvolumenumber];
-  ////////////////////////
-  // Setting Display Color
-  ////////////////////////
-  Int_t ssdflexcolor;
-  ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
-  TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
-                            fSSDKaptonFlexMedium);
-  ////////////////////////
-  // SSDFlexTrapezoidShape
-  ////////////////////////
-  const Int_t kssdflexvertexnumber = 2;
-  Double_t ssdflexwidth[kssdflexvertexnumber] = {fgkSSDFlexWidth[1],
-                                                                                               fgkSSDFlexWidth[0]};
-  TVector3* ssdflexvertex[kssdflexvertexnumber];
-  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 kssdflextubesegnumber = 2;
-  TGeoTubeSeg* ssdflextubesegshape[kssdflextubesegnumber];
-  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[kssdflextubesegnumber];
-  for(Int_t i = 0; i<kssdflextubesegnumber; 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[kssdflextubesegnumber];
-  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[kssdflextubesegnumber];
-  char ssdflextubesegname[30];
-  for(Int_t i=0; i<kssdflextubesegnumber; 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 kssdflexboxnumber = 7;
-  Double_t ssdflexboxlength[kssdflexboxnumber];
-  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[kssdflexboxnumber];
-  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[kssdflexboxnumber+1];
-  for(Int_t i=0; i<kssdflexboxnumber+1; i++) ssdflexboxshape[i] = 
-                                               (i!= kssdflexboxnumber ? new TGeoBBox("SSDFlexBoxShape",
-                                                               0.5*ssdflexboxlength[i],
-                                                               0.5*ssdflexboxwidth[i],0.5*SSDFlexHeigth) : 
-                                                               ssdflexboxshape[2]);
-  //////////////////////////////
-  //SSDFlex Box Shape CombiTrans 
-  //////////////////////////////
-  TGeoCombiTrans* ssdflexboxcombitrans[kssdflexboxnumber+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[kssdflexboxnumber+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<kssdflexboxnumber+1; i++){
-       sprintf(ssdflexboxname,"SSDFlexBox%i",i!=kssdflexboxnumber?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<kssdflexvolumenumber; i++) ssdflex->AddNode(ssdflexvolume[i],1);
-  return ssdflex;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength, 
-                                                                                                               Double_t SSDFlexHeigth){
+  // Carbon Fiber Junction 
   /////////////////////////////////////////////////////////////
-  // Method generating SSD End Flex   
-  /////////////////////////////////////////
-  // Setting Display Color, Media and Index
-  /////////////////////////////////////////
-  Int_t ssdflexcolor;
-  ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
-  TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
-                            fSSDKaptonFlexMedium);
-  ////////////////////////
-  const Int_t kssdendflexboxnumber = 5;
-  TGeoBBox* ssdendflexbboxshape[kssdendflexboxnumber];
-  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[kssdendflexboxnumber];  
-  char ssdendflexbboxname[30];
-  for(Int_t i=0; i<kssdendflexboxnumber; 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<kssdendflexboxnumber+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(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Flex Assembly    
-  /////////////////////////////////////////////////////////////
-  TGeoVolume* ssdflexassembly = new TGeoVolumeAssembly("SSDFlexAssembly");
-  const Int_t kssdflexlayernumber = 4;
-  Double_t ssdflexheight[kssdflexlayernumber];
-  Double_t ssdflexradius[kssdflexlayernumber];
-  TGeoTranslation* ssdflextrans[kssdflexlayernumber];
-  for(Int_t i=0; i<kssdflexlayernumber; 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(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Cooling Block Assembly    
-  /////////////////////////////////////////////////////////////
-  const Int_t kssdcoolingblocktransnumber = 2;
-  Double_t ssdcoolingblocktransvector[kssdcoolingblocktransnumber] = 
-                                       {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
-                                        fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
-                               -        fgkSSDCoolingBlockWidth};
-  TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock();
-  TGeoVolume* ssdcoolingblockassembly = 
-                                                         new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
-  for(Int_t i=0; i<kssdcoolingblocktransnumber; i++)
-    for(Int_t j=0; j<kssdcoolingblocktransnumber; j++) 
-               ssdcoolingblockassembly->AddNode(ssdcoolingblock,
-                                                 kssdcoolingblocktransnumber*i+j+1,
-                                                 new TGeoTranslation(i*ssdcoolingblocktransvector[0],
-                                                 j*ssdcoolingblocktransvector[1],0.));
-  return ssdcoolingblockassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
+  fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
   /////////////////////////////////////////////////////////////
-  // Method generating SSD Cooling Block    
+  // Carbon Fiber Lower Support
   /////////////////////////////////////////////////////////////
-  // Center Cooling Block Hole
-  ////////////////////////////
-  Double_t coolingblockholeangle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
-                                                       /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
-  Double_t coolingblockholewidth = fgkSSDCoolingBlockWidth;
-  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());
-                                               GetTriangleShape(coolingblockholevertex,
-                                               coolingblockholewidth,"CoolingBlockTriangleHoleShape");
-  TGeoRotation* coolingblockholerot = 
-                                                         new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
-  coolingblockholerot->RegisterYourself();
-    new TGeoCompositeShape("CoolingTubeHoleShape",
-                                                         "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
-                                                         "CoolingBlockHoleShape");
-  ///////////////////////////
-  // Cooling Block Trapezoids
-  ///////////////////////////
-  const Int_t kvertexnumber = 4;
-  const Int_t ktrapezoidnumber = 2;
-  TVector3** coolingblocktrapezoidvertex[ktrapezoidnumber];
-  for(Int_t i = 0; i<ktrapezoidnumber; i++) coolingblocktrapezoidvertex[i] = 
-                                               new TVector3*[kvertexnumber]; 
-  Double_t coolingblockcomponentheight = fgkSSDCoolingBlockHeight[0]
-                                   -   fgkSSDCoolingBlockHoleCenter
-                                       -       fgkSSDCoolingBlockHoleRadius[0]
-                                       *       TMath::Sin(coolingblockholeangle*TMath::DegToRad());
-  Double_t coolingblocktrapezoidlength[ktrapezoidnumber] = 
-                                       {       fgkSSDCoolingBlockLength,
-                                               0.5*(fgkSSDCoolingBlockLength-2.
-                                       *       (fgkSSDCoolingBlockHoleLength[1]
-                                       -       fgkSSDCoolingBlockHoleRadius[1])
-                                       -       fgkSSDCoolingBlockHoleLength[0])}; 
-  Double_t coolingblocktrapezoidheigth[ktrapezoidnumber] = 
-                                       {       fgkSSDCoolingBlockHeight[0]-coolingblockcomponentheight
-                                       -       fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
-                                       -       fgkSSDCoolingBlockHoleRadius[1],
-                                               coolingblockcomponentheight};
-  Double_t coolingblocktrapezoidwidth[ktrapezoidnumber]  = 
-                                               {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[ktrapezoidnumber] = 
-                                       {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
-  TGeoArb8* coolingblocktrapezoidshape[ktrapezoidnumber];
-  for(Int_t i = 0; i< ktrapezoidnumber; 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();
-       new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
-       "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
-       "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans"); 
+  TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
+  for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
+       fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
   /////////////////////////////
-  // Cooling Block Boxes Shapes
+  // SSD Sensor Support
   /////////////////////////////
-  const Int_t kboxnumber = 3;
-  TGeoBBox* coolingblockboxshape[kboxnumber];
-  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[kboxnumber-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<kboxnumber-1; i++) coolingblockboxtrans[i]->RegisterYourself();
-       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* ssdoolingblockshape = 
-               new TGeoCompositeShape("SSDCoolingBlockShape",  
-               "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
-               "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
-               "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
-  TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
-               ssdoolingblockshape,fSSDAlCoolBlockMedium);
-  return ssdcoolingblock;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
+  for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] = 
+                                                                               new TGeoVolume*[fgkssdsensorsupportnumber]; 
+  Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
+                                                                        fgkSSDSensorSideSupportThickness[1]};
+  for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
+       fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
+                                                                                          fgkSSDSensorSideSupportHeight[i],
+                                                                                          fgkSSDSensorSideSupportWidth,
+                                                                                          sidesupporthickness);  
+       fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
+                                                                                          fgkSSDSensorCenterSupportHeight[i],
+                                                                                          fgkSSDSensorCenterSupportWidth,
+                                                                                          sidesupporthickness);
+  }
   /////////////////////////////////////////////////////////////
-  // Method generating SSD Carbon Fiber Junction
+  // SSD Cooling Tube Support
   /////////////////////////////////////////////////////////////
-  const Int_t kvertexnumber = 4;
-  TVector3* vertex[kvertexnumber];
-  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*kvertexnumber; i++)
-       carbonfiberjunctionshapepiece->SetVertex(i,
-                                                       vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(),
-                                                       vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y());
-  TGeoRotation* carbonfiberjunctionrot = 
-                                               new TGeoRotation("CarbonFiberJunctionRot",
-                                                                                 180.,
-                                                                                 180.,
-                                                                                 180-2.*fgkCarbonFiberJunctionAngle[0]); 
-  TGeoVolume* carbonfiberjunctionpiece = 
-                                               new TGeoVolume("CarbonFiberJunctionPiece",
-                                               carbonfiberjunctionshapepiece,fSSDCarbonFiberMedium);
-  TGeoVolume* carbonfiberjunction = 
-                                               new TGeoVolumeAssembly("CarbonFiberJunction");
-  carbonfiberjunctionpiece->SetLineColor(fColorCarbonFiber);
-  carbonfiberjunction->AddNode(carbonfiberjunctionpiece,1);
-  carbonfiberjunction->AddNode(carbonfiberjunctionpiece,2,carbonfiberjunctionrot);
-  return carbonfiberjunction;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSD Carbon Fiber Junction Assembly    
-  /////////////////////////////////////////////////////////////
-  SetCarbonFiberJunctionCombiTransMatrix();
-  TGeoVolume* carbonfiberjunctionassembly = 
-                                                 new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
-  TGeoVolume* carbonfiberjunction = 
-                                                 GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
-  for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++) 
-    carbonfiberjunctionassembly->AddNode(carbonfiberjunction,i+1,
-                                                                                fCarbonFiberJunctionCombiTransMatrix[i]);
-  return carbonfiberjunctionassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
+  Int_t edgesnumber = 16;
+  fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);      
   /////////////////////////////////////////////////////////////
-  // Method returning a List containing pointers to Ladder Cable Volumes    
+  // SSD Hybrid
   /////////////////////////////////////////////////////////////
-  const Int_t kladdercablesegmentnumber = 2;
-  /////////////////////////////////////////
-  // LadderSegmentBBox Volume
-  /////////////////////////////////////////
-  TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
-  const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] = 
-                               {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
-  for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] = 
-                                                 new TGeoBBox(laddercablesegmentbboxshapename[i],
-                                                                          0.5*fgkSSDFlexWidth[0],
-                                                                          0.5*fgkSSDLadderCableWidth,
-                                                                          0.5*fgkSSDFlexHeight[i]); 
-  const char* laddercablesegmentbboxname[kladdercablesegmentnumber] = 
-                                                 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
-  TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
-  for(Int_t i=0; i<kladdercablesegmentnumber; i++){ 
-                       laddercablesegmentbbox[i] =
-                                                 new TGeoVolume(laddercablesegmentbboxname[i],
-                                                                                laddercablesegmentbboxshape[i],
-                                                                                (i==0?fSSDAlTraceLadderCableMedium:
-            fSSDKaptonLadderCableMedium));
-                       laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl : 
-                                                                                                                  fColorPolyhamide);
-  }
-  TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];                                                                               
-  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<kladdercablesegmentnumber; i++)  
-               laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
-                                                                                           laddercablesegmentbboxtrans[i]);
-/////////////////////////////////////////
-// LadderSegmentArb8 Volume
-/////////////////////////////////////////
-  const Int_t kvertexnumber = 4;
-  TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
-  for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] = 
-                                                                                                 new TVector3*[kvertexnumber];
-//Shape Vertex Positioning
-  for(Int_t i=0; i<kladdercablesegmentnumber; 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[kladdercablesegmentnumber] = 
-                                       {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
-  TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
-  for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] = 
-                                       GetArbShape(laddercablesegmentvertexposition[i],
-                                                               laddercablesegmentwidth[i],
-                                                               fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
-                                                               laddercablesegmentarbshapename[i]);
-  const char* laddercablesegmentarbname[kladdercablesegmentnumber] = 
-                                                 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
-  TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
-  for(Int_t i=0; i<kladdercablesegmentnumber; i++){
-                        laddercablesegmentarb[i] =
-                                                  new TGeoVolume(laddercablesegmentarbname[i],
-                                                                                 laddercablesegmentarbshape[i],
-                                                                                 (i==0?fSSDAlTraceLadderCableMedium:
-            fSSDKaptonLadderCableMedium)); 
-                        laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl : 
-                                                                                                                  fColorPolyhamide);
-}
-  TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
-  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<kladdercablesegmentnumber; i++)
-  laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
-                                                                                  laddercablesegmentarbcombitrans);
-/////////////////////////////////////////
-// End Ladder Cable Volume
-/////////////////////////////////////////
-  TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
-  const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] = 
-                               {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
-  for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] = 
-                                                 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
-                                                                          0.5*ssdendladdercablelength,
-                                                                          0.5*fgkSSDLadderCableWidth,
-                                                                          0.5*fgkSSDFlexHeight[i]);
-  const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] = 
-                                                 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
-  TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
-  for(Int_t i=0; i<kladdercablesegmentnumber; i++){ 
-                       ladderendcablesegmentbbox[i] =
-                                                 new TGeoVolume(ladderendcablesegmentbboxname[i],
-                                                                                ladderendcablesegmentbboxshape[i],
-                                                                                (i==0?fSSDAlTraceLadderCableMedium:
-            fSSDKaptonLadderCableMedium));
-                       ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl : 
-                                                                                                                  fColorPolyhamide);
-  }
-  TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];                                                                            
-  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<kladdercablesegmentnumber; 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* ssdhybridcomponentslist = GetSSDHybridParts();
+  for(Int_t i=0; i<fgkhybridcompnumber; i++) 
+       fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
   /////////////////////////////////////////////////////////////
-  // Method generating Ladder Cable Volumes Assemblies    
+  // SSD Cooling Block System
   /////////////////////////////////////////////////////////////
-  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){
+  fssdcoolingblocksystem = GetCoolingBlockSystem();
+   /////////////////////////////////////////////////////////////
+  // SSD Cooling Tube
   /////////////////////////////////////////////////////////////
-  // Method generating Ladder Cable Volumes Assembly   
+  TList* coolingtubelist = GetCoolingTubeList();       
+  for(Int_t i=0; i<fgkcoolingtubenumber; i++)  
+       fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
   /////////////////////////////////////////////////////////////
-  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.));
+  // SSD Flex  
+  /////////////////////////////////////////////////////////////
+  fssdstiffenerflex = GetSSDStiffenerFlex();
+  fssdendflex = GetSSDEndFlex();
+  ///////////////////////////////////
+  // End Ladder Carbon Fiber Junction
+  ///////////////////////////////////
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++) 
+                                                  fendladdercarbonfiberjunction[i] = 
+                                                  new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
+  for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+    fendladdercarbonfiberjunction[i][0] = 
+                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
+    fendladdercarbonfiberjunction[i][1] = 
+                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
   }
-  return laddercableassembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
+  ///////////////////////////////////
+  // End Ladder Mounting Block
+  ///////////////////////////////////
+  fendladdermountingblock = GetSSDMountingBlock();
   /////////////////////////////////////////////////////////////
-  // Method generating Ladder Cable List Assemblies  
-  /////////////////////////////////////////////////////////////  
-  const Int_t kladdercableassemblynumber = 2;
-  TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
-  TGeoVolume* ladderCable[kladdercableassemblynumber];
-  char laddercableassemblyname[30];
-  TList* laddercableassemblylist = new TList();
-  for(Int_t i=0; i<kladdercableassemblynumber; 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;
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+  delete carbonfibersupportlist;
+  delete carbonfiberlowersupportlist;
+  delete ssdhybridcomponentslist;
+  /////////////////////////////////////////////////////////////
+  fBasicObjects = kTRUE;
 }
 /////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
+void AliITSv11GeometrySSD::SetSSDSensor(){
+  ////////////////////////////////////////////////////////////////
+  // Method generating SSD Sensors: it sets the private variables
+  // fSSDSensor5, fSSDSensor6  
+  ////////////////////////////////////////////////////////////////
+  Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
+  Double_t ssdsensitivewidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
+  TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
+                                                0.5*ssdsensitivewidth,
+                                                0.5*fgkSSDSensorHeight,
+                                                0.5*ssdsensitivelength);
+  TGeoVolume* ssdsensorsensitiveLay5 = 
+       new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
+  TGeoVolume* ssdsensorsensitiveLay6 = 
+       new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
+  ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
+  ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
+  TGeoBBox* ssdsensorinsensitiveshape[2];
+  ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
+                                                0.5*fgkSSDSensorInsensitiveWidth,
+                                                0.5*fgkSSDSensorHeight,
+                                                0.5*fgkSSDSensorLength);
+  ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
+                                                0.5*ssdsensitivewidth,
+                                                0.5*fgkSSDSensorHeight,
+                                                0.5*fgkSSDSensorInsensitiveWidth);
+  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],
+                     fSSDSensorMedium);
+      ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
+  }
   /////////////////////////////////////////////////////////////
-  // Method generating the End Ladder Carbon Fiber Junction Assembly   
-  /////////////////////////////////////////////////////////////  
-  const Int_t kendlabbercarbonfiberjunctionumber = 2;
-  TGeoVolume* endladdercarbonfiberjunctionassembly[kendlabbercarbonfiberjunctionumber];
-  endladdercarbonfiberjunctionassembly[0] = 
-                               new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
-  endladdercarbonfiberjunctionassembly[1] = 
-                               new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
-  TGeoVolume** endladdercarbonfiberjunction[kendlabbercarbonfiberjunctionumber];
-  for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++) 
-                                                  endladdercarbonfiberjunction[i] = new TGeoVolume*[2];
-  for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
-    endladdercarbonfiberjunction[i][0] = 
-                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
-    endladdercarbonfiberjunction[i][1] = 
-                 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
+  // Virtual Volume containing SSD Sensor  
+  /////////////////////////////////////////////////////////////
+  TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
+                                                                                            0.5*fgkSSDSensorWidth,
+                                                                                            0.5*fgkSSDSensorHeight,
+                                                                                            0.5*fgkSSDSensorLength);
+  fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
+                                                                                fSSDAir);      
+  fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
+                                                                                fSSDAir);      
+  /////////////////////////////////////////////////////////////
+  for(Int_t i=0; i<4; i++){ 
+            fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
+            ssdsensorinsensitive[1],i<2?1:2,
+                       new TGeoTranslation(
+                        0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
+      *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,                 
+                       0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
+      *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));    
+            fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
+            ssdsensorinsensitive[1],i<2?1:2,
+                       new TGeoTranslation(
+                        0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
+      *   (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,                 
+                       0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
+      *   (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));    
   }
-  TList* endladdercarbonfiberjunctionlist = new TList();
-  for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
-    SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
-    for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
-      endladdercarbonfiberjunctionassembly[i]->AddNode(j==2 ? 
-                                                endladdercarbonfiberjunction[i][1] : 
-                                                endladdercarbonfiberjunction[i][0],
-                                                j+1,fEndLadderCarbonFiberJunctionCombiTransMatrix[j]);
-    endladdercarbonfiberjunctionlist->Add(endladdercarbonfiberjunctionassembly[i]);
-  }
-  return endladdercarbonfiberjunctionlist;
+    fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
+    fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
 }
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
-  /////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
+  /////////////////////////////////////////////////////////////  
   // Method generating the Carbon Fiber Support   
   /////////////////////////////////////////////////////////////  
   const Int_t kvertexnumber = 4;
@@ -2556,55 +1559,76 @@ TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
                                                          (GetReflection(vertexposition[0][j],param))->Y());
   char* carbonfibersupportshapename[kshapesnumber] = 
                                                {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
+  char* carbonfibersupportname[kshapesnumber] = 
+                                               {"CarbonFiberSupport1","CarbonFiberSupport2"};
   TGeoArb8* carbonfibersupportshape[kshapesnumber]; 
+  TGeoVolume* carbonfibersupport[kshapesnumber];
+  TList* carbonfibersupportlist = new TList();
   Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
   Double_t carbonfibersupportheight = 
          carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
          *TMath::DegToRad());
-  for(Int_t i = 0; i< kshapesnumber; i++) carbonfibersupportshape[i] = 
+  for(Int_t i = 0; i< kshapesnumber; 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,fSSDCarbonFiberMedium);
-  carbonfibersupport->SetLineColor(fColorCarbonFiber);
-  TGeoVolume* carbonfibersupportassembly = 
-                                                   new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
-  carbonfibersupportassembly->AddNode(carbonfibersupport,1);
-  carbonfibersupportassembly->AddNode(carbonfibersupport,2,
-                                                                         carbonfibersupportcombitrans);
-  return carbonfibersupportassembly;
+                                                               carbonfibersupportshapename[i],i==0 ? 1: -1);
+   carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
+                                                  carbonfibersupportshape[i],fSSDCarbonFiberMedium);
+   carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
+   carbonfibersupportlist->Add(carbonfibersupport[i]); 
+   }
+  /////////////////////////////////////////////////////////////
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+  for(Int_t i=0; i< kshapesnumber; i++){
+     for(Int_t j=0; j< kvertexnumber; j++)
+          delete vertexposition[i][j];
+       delete [] vertexposition[i];
+  }
+  delete [] param;
+  /////////////////////////////////////////////////////////////
+   return carbonfibersupportlist;
+}
+/////////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
+  /////////////////////////////////////////////////////////////
+  // Method generating SSD Carbon Fiber Junction
+  /////////////////////////////////////////////////////////////
+  const Int_t kvertexnumber = 6;
+  TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
+  Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
+                                                         *  TMath::DegToRad()),-1.,0.};
+  TVector3* vertex[kvertexnumber];
+  vertex[0] = new TVector3();
+  vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
+                       *                         TMath::Cos(fgkCarbonFiberJunctionAngle[0]
+                       *                         TMath::DegToRad()),
+                                                 fgkCarbonFiberJunctionEdge[0]
+                       *                         TMath::Sin(fgkCarbonFiberJunctionAngle[0]
+                       *                         TMath::DegToRad()));
+  vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
+                                                  fgkCarbonFiberJunctionEdge[1]);
+  vertex[5] = new TVector3(fgkCarbonFiberJunctionLength); 
+  vertex[1] = GetReflection(vertex[5],reflectionparam);        
+  vertex[2] = GetReflection(vertex[4],reflectionparam);        
+  Double_t xvertexpoints[6], yvertexpoints[6];
+  for(Int_t i=0; i<kvertexnumber; i++) 
+         xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
+  carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
+  carbonfiberjunctionshape->DefineSection(0,-0.5*width);
+  carbonfiberjunctionshape->DefineSection(1,0.5*width);
+  TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
+                                                               carbonfiberjunctionshape,fSSDCarbonFiberMedium);
+  carbonfiberjunction->SetLineColor(fColorCarbonFiber);
+  /////////////////////////////////////////////////////////////
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+  for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
+  ///////////////////////////////////////////////////////////// 
+  return carbonfiberjunction;
 }
 ////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
+TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
   /////////////////////////////////////////////////////////////
   // Method generating the Carbon Fiber Lower Support   
   /////////////////////////////////////////////////////////////  
@@ -2634,203 +1658,898 @@ TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t
   vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
   vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
                                                                fgkCarbonFiberLowerSupportVolumePosition[1]);
-  char* carbonfiberlowersupportname[kshapesnumber] = 
+  char* carbonfiberlowersupportshapename[kshapesnumber] = 
                          {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
+  char* carbonfiberlowersupportname[kshapesnumber] = 
+                         {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
   TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
-  for(Int_t i = 0; i< kshapesnumber; i++) carbonfiberlowersupportshape[i] = 
+  TGeoVolume* carbonfiberlowersupport[kshapesnumber];
+  TList* carbonfiberlowersupportlist = new TList();
+  for(Int_t i = 0; i< kshapesnumber; i++){ 
+       carbonfiberlowersupportshape[i] = 
                                                                GetArbShape(vertexposition[i],width,
                                                                                        fgkCarbonFiberLowerSupportHeight,
-                                                                                       carbonfiberlowersupportname[i]);
-  ///////////////////////////////////////////////////////
-  TGeoTranslation* carbonfiberlowersupporttrans[kshapesnumber];
-  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< kshapesnumber; 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,fSSDCarbonFiberMedium);
-  carbonfiberlowersupport->SetLineColor(fColorCarbonFiber);
-  return carbonfiberlowersupport;
+                                                                                       carbonfiberlowersupportshapename[i]);
+    carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
+                                               carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
+       carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
+    carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
+  }
+  /////////////////////////////////////////////////////////////
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+  for(Int_t i=0; i< kshapesnumber; i++){
+     for(Int_t j=0; j< kvertexnumber; j++)
+          delete vertexposition[i][j];
+       delete [] vertexposition[i];
+  }
+  /////////////////////////////////////////////////////////////
+  return carbonfiberlowersupportlist;
 }
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height, 
+                                                                Double_t width, Double_t* thickness)const{
   /////////////////////////////////////////////////////////////
-  // Method generating the Carbon Fiber Assembly Support   
+  // Method generating the Sensor Support   
   /////////////////////////////////////////////////////////////  
-  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,
-                                               fCarbonFiberAssemblyCombiTransMatrix[i]);
-  return carbonfiberassemblysupport;
+       const Int_t kvertexnumber = 6;
+       TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);      
+    TVector3* vertexposition[kvertexnumber];
+       vertexposition[0] = new TVector3();     
+       vertexposition[1] = new TVector3(0.0,length);   
+       vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());  
+       vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);  
+       vertexposition[4] = new TVector3(height,vertexposition[3]->Y());        
+       vertexposition[5] = new TVector3(vertexposition[4]->X());       
+       Double_t xvertexpoints[6], yvertexpoints[6];
+       for(Int_t i=0; i<kvertexnumber; i++) 
+               xvertexpoints[i] = vertexposition[i]->X(), 
+               yvertexpoints[i] = vertexposition[i]->Y();
+    ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
+    ssdsensorsupportshape->DefineSection(0,-0.5*width);
+    ssdsensorsupportshape->DefineSection(1,0.5*width);
+    TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
+                                                                ssdsensorsupportshape,fSSDSensorSupportMedium);
+  /////////////////////////////////////////////////////////////
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+       for (Int_t i=0; i<kvertexnumber; i++)
+               delete vertexposition[i];
+  /////////////////////////////////////////////////////////////
+    return ssdsensorsupport;
 }
 ////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
   /////////////////////////////////////////////////////////////
   // Method generating the Cooling Tube Support
-  /////////////////////////////////////////////////////////////  
-  const Int_t kvertexnumber = 3;
+  /////////////////////////////////////////////////////////////
+  if(nedges%2!=0) nedges--;    
+  const Int_t kvertexnumber = nedges+5;
   Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
                           /                     fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
-                                               new TGeoTubeSeg("CoolingTubeSegShape",0.0,
-                                                       fgkCoolingTubeSupportRmax,
-                                                       0.5*fgkCoolingTubeSupportWidth,phi,
-                                                       360-phi);
-                                               new TGeoTube("CoolingTubeHoleShape",0.0,
-                                                       fgkCoolingTubeSupportRmin,
-                                                       0.5*fgkCoolingTubeSupportWidth);
-  TVector3* vertexposition[kvertexnumber];
-  ///////////////////////////
-  //Shape Vertex Positioning
-  ///////////////////////////
-  vertexposition[0] = new TVector3();
-  vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax
-                                       *               TMath::Cos(phi*TMath::DegToRad()),
-                                                       fgkCoolingTubeSupportRmax
-                                       *               TMath::Sin(phi*TMath::DegToRad()));
+  Double_t angle = 90.+phi;
+  Double_t psi = 90.-phi;
+  ///////////////////////////////////////
+  // Vertex Positioning for TGeoXTru
+  ///////////////////////////////////////
+  TVector3** vertexposition = new TVector3*[kvertexnumber];
+  vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
+                                                                  fgkCoolingTubeSupportRmin*SinD(angle));
+  vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
+                                                                  fgkCoolingTubeSupportRmax*SinD(angle));
   vertexposition[2] = new TVector3(vertexposition[1]->X(),
-                                       -                          vertexposition[1]->Y());
-  GetTriangleShape(vertexposition,
-                                                                          fgkCoolingTubeSupportWidth,
-                                                                          "CoolingTubeTriangleShape");
+                                                                  fgkCoolingTubeSupportRmax);
+  vertexposition[3] = new TVector3(-vertexposition[1]->X(),
+                                                                  fgkCoolingTubeSupportRmax);
+  vertexposition[4] = new TVector3(-vertexposition[1]->X(),
+                                                                   vertexposition[1]->Y());
+  for(Int_t i=0; i<nedges; i++)
+       vertexposition[i+5] = 
+               new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
+                                        fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
+  ///////////////////////////////////////////////////////////////////////
+  // TGeoXTru Volume definition for Cooling Tube Support Arc Part
+  ///////////////////////////////////////////////////////////////////////
+  TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);      
+  Double_t* xvertexpoints = new Double_t[kvertexnumber];       
+  Double_t* yvertexpoints = new Double_t[kvertexnumber];       
+  for(Int_t i=0; i<kvertexnumber; i++){
+       xvertexpoints[i] = vertexposition[i]->X();
+       yvertexpoints[i] = vertexposition[i]->Y();
+  } 
+  coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
+                                                                                       yvertexpoints);
+  coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+  coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+  TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
+                                                                         coolingtubesupportarcshape,
+                                                                                 fSSDTubeHolderMedium);
+  coolingtubesupportarc->SetLineColor(fColorG10);
+  //////////////////////////////////////////////////////////////////////////
+  // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
+  //////////////////////////////////////////////////////////////////////////
+  TGeoTubeSeg* coolingtubesupportsegshape = 
+                                                       new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
+                                                                                       fgkCoolingTubeSupportRmax,
+                                                                                       0.5*fgkCoolingTubeSupportWidth,
+                                                                                       phi,360-phi);
+  TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
+                                                                                       coolingtubesupportsegshape,
+                                                                                       fSSDTubeHolderMedium);
+  coolingtubesupportseg->SetLineColor(fColorG10);
+  //////////////////////////////////////////////////////////////////////////
+  // TGeoBBox Volume definition for Cooling Tube Support Box Part
+  //////////////////////////////////////////////////////////////////////////
   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.;
-                                               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,fSSDTubeHolderMedium);
-  return coolingtubesupport;
+  Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
+  boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
+  TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
+                                                                                0.5*fgkCoolingTubeSupportHeight,
+                                                                                0.5*fgkCoolingTubeSupportWidth,boxorigin);
+  TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
+                               coolingtubesupportboxshape,fSSDTubeHolderMedium);
+  coolingtubesupportbox->SetLineColor(fColorG10);
+  //////////////////////////////////////////////////////////////////////////
+  // Cooling Tube for Cooling Tube Support 
+  //////////////////////////////////////////////////////////////////////////
+  TGeoXtru* coolingtubearcshape[2];
+  coolingtubearcshape[0] = new TGeoXtru(2);    
+  Double_t* xvert = new Double_t[nedges+2];
+  Double_t* yvert = new Double_t[nedges+2];
+  Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
+  ////////////////////////////////////////
+  // Positioning the vertices for TGeoXTru
+  ////////////////////////////////////////
+  xvert[0] = 0., yvert[0] = 0.;
+  xvert[1] = vertexposition[0]->X()*ratio,  yvert[1] = vertexposition[0]->Y()*ratio;
+  for(Int_t i=0; i< nedges; i++)
+               xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
+               yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
+  ////////////////////////////////////////
+  // Defining TGeoXTru PolyGone
+  ////////////////////////////////////////
+  coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
+  coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+  coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+  coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
+               fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
+  TGeoVolume* coolingtubearc[2];
+  coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
+                                                                 coolingtubearcshape[0],fSSDCoolingTubeWater);
+  coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
+                                                                 coolingtubearcshape[1],fSSDCoolingTubePhynox);
+  coolingtubearc[0]->SetLineColor(fColorWater);
+  coolingtubearc[1]->SetLineColor(fColorPhynox);
+  ////////////////////////////////////////////
+  // Defining TGeoTubeSeg Part of Cooling Tube
+  ////////////////////////////////////////////
+  TGeoTubeSeg* coolingtubesegshape[2];
+  coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+                                                       0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
+  coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
+                                                       0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
+  TGeoVolume* coolingtubeseg[2];
+  coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
+                                                                coolingtubesegshape[0],fSSDCoolingTubePhynox);
+  coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
+                                                                coolingtubesegshape[1],fSSDCoolingTubeWater);
+  coolingtubeseg[0]->SetLineColor(fColorPhynox);
+  coolingtubeseg[1]->SetLineColor(fColorWater);
+  /////////////////////////////////////////////////////////////
+  // Virtual Volume containing Cooling Tube Support  
+  /////////////////////////////////////////////////////////////
+  TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
+  const Int_t kvirtualvertexnumber = 8;
+  TVector3* virtualvertex[kvirtualvertexnumber];
+   ////////////////////////////////////////
+  // Positioning the vertices for TGeoXTru
+  ////////////////////////////////////////
+  virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax); 
+  virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
+  virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
+  virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
+  virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
+  virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
+  virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
+  virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
+  Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
+  for(Int_t i=0; i< kvirtualvertexnumber; i++)
+       xmothervertex[i] = virtualvertex[i]->X(),
+       ymothervertex[i] = virtualvertex[i]->Y();
+  ////////////////////////////////////////
+  // Defining TGeoXTru PolyGone
+  ////////////////////////////////////////
+  virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
+                                                                                                                                        ymothervertex);
+  virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+  virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+  TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
+                                                                virtualCoolingTubeSupportShape,fSSDAir);
+  ////////////////////////////////////////
+  // Positioning Volumes in Virtual Volume
+  ////////////////////////////////////////
+  TGeoRotation* coolingtubesupportrot = new TGeoRotation(); 
+  coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
+  virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
+  virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
+  virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
+  virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
+  virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
+  virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
+  virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
+  /////////////////////////////////////////////////////////////
+  // Deallocating memory
+  /////////////////////////////////////////////////////////////
+  delete [] vertexposition;
+  delete xvertexpoints;
+  delete yvertexpoints;
+  delete xvert;
+  delete yvert;
+  for(Int_t i=0; i< kvirtualvertexnumber; i++)
+       delete virtualvertex[i];
+  /////////////////////////////////////////////////////////////
+       return virtualcoolingtubesupport;
 }
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
+/////////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
+  /////////////////////////////////////////////////////////////
+  // Method generating List containing SSD Hybrid Components   
+  /////////////////////////////////////////////////////////////
+  TList* ssdhybridlist = new TList();
+  const Int_t kssdstiffenernumber = 2;
+  Double_t ssdstiffenerseparation = fgkSSDSensorLength
+                                                                 - 2.*fgkSSDModuleStiffenerPosition[1]
+                                                                 -    fgkSSDStiffenerWidth;
+  Double_t ssdchipcablesradius[kssdstiffenernumber];
+  for(Int_t i=0; i<kssdstiffenernumber; i++)
+         ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
+                              -  fgkSSDChipCablesHeight[0]
+                              -  fgkSSDChipCablesHeight[1]);
+  /////////////////////////////////////////////////////////////
+  // Mother Volumes Containers 
+  /////////////////////////////////////////////////////////////
+  const Int_t kmothernumber = 2;
+  const Int_t kmothervertexnumber = 12;
+  Double_t xmothervertex[kmothernumber][kmothervertexnumber]; 
+  Double_t ymothervertex[kmothernumber][kmothervertexnumber]; 
+  ///////////////////////
+  // Setting the vertices 
+  ///////////////////////
+  xmothervertex[0][0]  = -0.5*fgkSSDStiffenerLength;
+  xmothervertex[0][1]  = xmothervertex[0][0]; 
+  xmothervertex[0][2]  = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
+  xmothervertex[0][3]  = xmothervertex[0][2];
+  xmothervertex[0][4]  = xmothervertex[0][0];
+  xmothervertex[0][5]  = xmothervertex[0][4];
+  xmothervertex[0][6]  = -xmothervertex[0][0];
+  xmothervertex[0][7]  = xmothervertex[0][6];
+  xmothervertex[0][8]  = -xmothervertex[0][2];
+  xmothervertex[0][9]  = xmothervertex[0][8];
+  xmothervertex[0][10] = xmothervertex[0][7];
+  xmothervertex[0][11] = xmothervertex[0][10];
+  for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
+  for(Int_t i = 0; i<kmothernumber; i++){
+      ymothervertex[i][0]  = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
+                           + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
+      ymothervertex[i][1]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
+      ymothervertex[i][2]  = ymothervertex[i][1];
+      ymothervertex[i][3]  = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
+      ymothervertex[i][4]  = ymothervertex[i][3];
+      ymothervertex[i][5]  = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
+      ymothervertex[i][6]  = ymothervertex[i][5];
+      ymothervertex[i][7]  = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
+      ymothervertex[i][8]  = ymothervertex[i][7];
+      ymothervertex[i][9]  = 0.5*fgkSSDStiffenerWidth;
+      ymothervertex[i][10] = ymothervertex[i][9];
+      ymothervertex[i][11] = ymothervertex[i][0];
+  }
+  TGeoXtru* ssdhybridmothershape[kmothernumber];
+  TGeoVolume* ssdhybridmother[kmothernumber];
+  const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
+  for(Int_t i=0; i<kmothernumber; i++){
+      ssdhybridmothershape[i] = new TGeoXtru(2);
+      ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
+                                          ymothervertex[i]);
+      ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight      
+                                               -fgkSSDChipCablesHeight[i+2]);
+      ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
+      ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
+                                          fSSDAir);
+   }   
+  /////////////////////////////////////////////////////////////
+  // SSD Stiffener   
+  /////////////////////////////////////////////////////////////
+  TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
+                                             0.5*fgkSSDStiffenerLength,
+                                             0.5*fgkSSDStiffenerWidth,
+                                             0.5*fgkSSDStiffenerHeight);
+  TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
+                                            fSSDStiffenerMedium);  
+  ssdstiffener->SetLineColor(fColorStiffener); 
+  TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
+  for(Int_t i=0; i<kssdstiffenernumber; i++) 
+      ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
+  /////////////////////////////////////////////////////////////
+  // SSD Chip System   
+  /////////////////////////////////////////////////////////////
+  TList* ssdchipsystemlist = GetSSDChipSystem(); 
+  Double_t ssdchipseparation = fgkSSDSensorLength
+                             - 2.*fgkSSDModuleStiffenerPosition[1]
+                             - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
+                             - 0.5*fgkSSDChipWidth);
+  Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength 
+                              +  fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
+  TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
+                                      - 0.5*ssdchipsystemlength,
+                        &