Contents of SDD and SPD trays revised and fixed (M. Sitta)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Sep 2010 09:12:27 +0000 (09:12 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Sep 2010 09:12:27 +0000 (09:12 +0000)
ITS/AliITSv11GeometrySupport.cxx
ITS/AliITSv11GeometrySupport.h
ITS/AliITSv11Hybrid.cxx

index cd65af0..17f111e 100644 (file)
@@ -3343,15 +3343,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
 //
 // Created:      15 Feb 2010  Mario Sitta
 // Updated:      10 Jun 2010  Mario Sitta  Freon inside cooling pipes
+// Updated:      08 Sep 2010  Mario Sitta
 //
 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
 // drawings and other (oral) information given by F.Tosello and D.Elia
 // (small differences with blueprints - e.g. -0.07mm in R1Trans and
 // R2Trans - fix small overlaps; they are then compensated in positioning
 // the Rear Tray to avoid its own overlaps with the rear supporting ring)
-// Optical cables and low voltage cables are approximated with mean
-// materials and square cross sections, but preserving the total material
-// budget.
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
 //
 
   // Overall position and rotation of the A-Side Cable Trays
@@ -3379,12 +3379,16 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   const Double_t kExternalTrayHigh       = kForwardTraySecondHigh;
   const Double_t kExternalTrayThick      = kForwardTrayThick;
 
-  const Double_t kCoolingTubeRmin        =    5.00 *fgkmm;
-  const Double_t kCoolingTubeRmax        =    6.00 *fgkmm;
+  const Double_t kCoolingTubeRmin        =    2.00 *fgkmm;
+  const Double_t kCoolingTubeRmax        =    3.00 *fgkmm;
 
   const Double_t kOpticalFibersSect      =    8.696*fgkmm;//!!!ESTIMATED!!!
-  const Double_t kLowVoltageCableSect    =    3.412*fgkmm;//!!!ESTIMATED!!!
-  const Double_t kHiVoltageCableSect     =    1.873*fgkmm;//!!!ESTIMATED!!!
+  const Double_t kLowVoltageCableSectCu  =    7.675*fgkmm;// Computed
+  const Double_t kLowVoltageCableHighPUR =    1.000*fgkmm;// Computed
+  const Double_t kHiVoltageCableSectCu   =    1.535*fgkmm;// Computed
+  const Double_t kHiVoltageCableHighPUR  =    0.500*fgkmm;// Computed
+  const Double_t kCoaxCableSectCu        =    6.140*fgkmm;//!!!ESTIMATED!!!
+  const Double_t kCoaxCableHighPUR       =    1.000*fgkmm;//!!!ESTIMATED!!!
 
 
   // Local variables
@@ -3510,14 +3514,18 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   optFibsExt->DefineSection(0, 0);
   optFibsExt->DefineSection(1, kOpticalFibersSect);
 
-  // The Low Voltage cables inside the forward tray: a BBox
-  TGeoBBox *lowCablesForw = new TGeoBBox(kLowVoltageCableSect/2,
-                                        kLowVoltageCableSect/2,
-                                        kForwardTrayTotalLen/2);
+  // The Low Voltage cables inside the forward tray: two BBox
+  TGeoBBox *lowCablesForwCu = new TGeoBBox(kLowVoltageCableSectCu,
+                                          kLowVoltageCableSectCu/4,
+                                          kForwardTrayTotalLen/2);
+
+  TGeoBBox *lowCablesForwPUR = new TGeoBBox(kLowVoltageCableSectCu,
+                                           kLowVoltageCableHighPUR/4,
+                                           kForwardTrayTotalLen/2);
 
-  // The Low Voltage inside the external tray: a Xtru
-  TGeoXtru *lowCablesExt = new TGeoXtru(2);
-  lowCablesExt->SetName("ITSsuppSPDExtTrayLowVoltage");
+  // The Low Voltage inside the external tray: two Xtru
+  TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
+  lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
 
   yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
           + 2*forwTrayWall->GetDY();
@@ -3525,22 +3533,85 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   xprof[1] = kExternalTrayLen;
   yprof[1] = yprof[0];
   xprof[2] = xprof[1];
-  yprof[2] = yprof[1] + kLowVoltageCableSect;
+  yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
   yprof[3] = yprof[2];
   xprof[3] = yprof[2]*TanD(kTrayAZRot);
 
-  lowCablesExt->DefinePolygon(4, xprof, yprof);
-  lowCablesExt->DefineSection(0, 0);
-  lowCablesExt->DefineSection(1, kLowVoltageCableSect);
+  lowCablesExtCu->DefinePolygon(4, xprof, yprof);
+  lowCablesExtCu->DefineSection(0, 0);
+  lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
 
-  // The High Voltage cables inside the forward tray: a BBox
-  TGeoBBox *hiCablesForw = new TGeoBBox(kHiVoltageCableSect/2,
-                                       kHiVoltageCableSect/2,
-                                       kForwardTrayTotalLen/2);
+  TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
+  lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
+
+  xprof[0] = lowCablesExtCu->GetX(3);
+  yprof[0] = lowCablesExtCu->GetY(3);
+  xprof[1] = lowCablesExtCu->GetX(2);
+  yprof[1] = lowCablesExtCu->GetY(2);
+  xprof[2] = xprof[1];
+  yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
+  yprof[3] = yprof[2];
+  xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+  lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
+  lowCablesExtPUR->DefineSection(0, 0);
+  lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
+
+  // The High Voltage cables inside the forward tray: two BBox
+  TGeoBBox *hiCablesForwCu = new TGeoBBox(kHiVoltageCableSectCu,
+                                         kHiVoltageCableSectCu/4,
+                                         kForwardTrayTotalLen/2);
+
+  TGeoBBox *hiCablesForwPUR = new TGeoBBox(kHiVoltageCableSectCu,
+                                          kHiVoltageCableHighPUR/4,
+                                          kForwardTrayTotalLen/2);
+
+  // The High Voltage inside the external tray: two Xtru
+  TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
+  hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
+
+  yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+          + 2*forwTrayWall->GetDY();
+  xprof[0] = yprof[0]*TanD(kTrayAZRot);
+  xprof[1] = kExternalTrayLen;
+  yprof[1] = yprof[0];
+  xprof[2] = xprof[1];
+  yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
+  yprof[3] = yprof[2];
+  xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+  hiCablesExtCu->DefinePolygon(4, xprof, yprof);
+  hiCablesExtCu->DefineSection(0, 0);
+  hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
+
+  TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
+  hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
+
+  xprof[0] = hiCablesExtCu->GetX(3);
+  yprof[0] = hiCablesExtCu->GetY(3);
+  xprof[1] = hiCablesExtCu->GetX(2);
+  yprof[1] = hiCablesExtCu->GetY(2);
+  xprof[2] = xprof[1];
+  yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
+  yprof[3] = yprof[2];
+  xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+  hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
+  hiCablesExtPUR->DefineSection(0, 0);
+  hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
 
-  // The High Voltage inside the external tray: a Xtru
-  TGeoXtru *hiCablesExt = new TGeoXtru(2);
-  hiCablesExt->SetName("ITSsuppSPDExtTrayHiVoltage");
+  // The Coaxial cables inside the forward tray: two BBox
+  TGeoBBox *coaxCablesForwCu = new TGeoBBox(kCoaxCableSectCu,
+                                           kCoaxCableSectCu/4,
+                                           kForwardTrayTotalLen/2);
+
+  TGeoBBox *coaxCablesForwPUR = new TGeoBBox(kCoaxCableSectCu,
+                                            kCoaxCableHighPUR/4,
+                                            kForwardTrayTotalLen/2);
+
+  // The Coaxial inside the external tray: two Xtru
+  TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
+  coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
 
   yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
           + 2*forwTrayWall->GetDY();
@@ -3548,13 +3619,29 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   xprof[1] = kExternalTrayLen;
   yprof[1] = yprof[0];
   xprof[2] = xprof[1];
-  yprof[2] = yprof[1] + kHiVoltageCableSect;
+  yprof[2] = yprof[1] + kCoaxCableSectCu/2;
+  yprof[3] = yprof[2];
+  xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+  coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
+  coaxCablesExtCu->DefineSection(0, 0);
+  coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
+
+  TGeoXtru *coaxCablesExtPUR = new TGeoXtru(2);
+  coaxCablesExtPUR->SetName("ITSsuppSPDExtTrayCoaxPUR");
+
+  xprof[0] = coaxCablesExtCu->GetX(3);
+  yprof[0] = coaxCablesExtCu->GetY(3);
+  xprof[1] = coaxCablesExtCu->GetX(2);
+  yprof[1] = coaxCablesExtCu->GetY(2);
+  xprof[2] = xprof[1];
+  yprof[2] = yprof[1] + kCoaxCableHighPUR/2;
   yprof[3] = yprof[2];
   xprof[3] = yprof[2]*TanD(kTrayAZRot);
 
-  hiCablesExt->DefinePolygon(4, xprof, yprof);
-  hiCablesExt->DefineSection(0, 0);
-  hiCablesExt->DefineSection(1, kHiVoltageCableSect);
+  coaxCablesExtPUR->DefinePolygon(4, xprof, yprof);
+  coaxCablesExtPUR->DefineSection(0, 0);
+  coaxCablesExtPUR->DefineSection(1, kCoaxCableSectCu*2);
 
 
   // We have all shapes: now create the real volumes
@@ -3562,8 +3649,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   TGeoMedium *medIn    = mgr->GetMedium("ITS_INOX$");
   TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
   TGeoMedium *medFibs  = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
-  TGeoMedium *medLVC   = mgr->GetMedium("ITS_SPD_LOWCABLES$");
-  TGeoMedium *medHVC   = mgr->GetMedium("ITS_SPD_HICABLES$");
+  TGeoMedium *medCu    = mgr->GetMedium("ITS_COPPER$");
+  TGeoMedium *medPUR   = mgr->GetMedium("ITS_POLYURETHANE$");
 
   TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
                                            forwTrayLowerFace, medAl);
@@ -3709,41 +3796,113 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   extOptFibs->SetFillColor(extOptFibs->GetLineColor());
   extOptFibs->SetFillStyle(4000); // 0% transparent
 
-  TGeoVolume *forwLowCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayLowCabs",
-                                          lowCablesForw, medLVC);
-
-  forwLowCabs->SetVisibility(kTRUE);
-  forwLowCabs->SetLineColor(kRed); // Red
-  forwLowCabs->SetLineWidth(1);
-  forwLowCabs->SetFillColor(forwLowCabs->GetLineColor());
-  forwLowCabs->SetFillStyle(4000); // 0% transparent
-
-  TGeoVolume *extLowCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayLowCabs",
-                                         lowCablesExt, medLVC);
-
-  extLowCabs->SetVisibility(kTRUE);
-  extLowCabs->SetLineColor(kRed); // Red
-  extLowCabs->SetLineWidth(1);
-  extLowCabs->SetFillColor(extLowCabs->GetLineColor());
-  extLowCabs->SetFillStyle(4000); // 0% transparent
-
-  TGeoVolume *forwHiCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabs",
-                                         hiCablesForw, medHVC);
-
-  forwHiCabs->SetVisibility(kTRUE);
-  forwHiCabs->SetLineColor(kRed); // Red
-  forwHiCabs->SetLineWidth(1);
-  forwHiCabs->SetFillColor(forwHiCabs->GetLineColor());
-  forwHiCabs->SetFillStyle(4000); // 0% transparent
-
-  TGeoVolume *extHiCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabs",
-                                        hiCablesExt, medHVC);
-
-  extHiCabs->SetVisibility(kTRUE);
-  extHiCabs->SetLineColor(kRed); // Red
-  extHiCabs->SetLineWidth(1);
-  extHiCabs->SetFillColor(extHiCabs->GetLineColor());
-  extHiCabs->SetFillStyle(4000); // 0% transparent
+  TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
+                                            lowCablesForwCu, medCu);
+
+  forwLowCabsCu->SetVisibility(kTRUE);
+  forwLowCabsCu->SetLineColor(kRed); // Red
+  forwLowCabsCu->SetLineWidth(1);
+  forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
+  forwLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
+                                             lowCablesForwPUR, medPUR);
+
+  forwLowCabsPUR->SetVisibility(kTRUE);
+  forwLowCabsPUR->SetLineColor(kBlack); // Black
+  forwLowCabsPUR->SetLineWidth(1);
+  forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
+  forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
+                                           lowCablesExtCu, medCu);
+
+  extLowCabsCu->SetVisibility(kTRUE);
+  extLowCabsCu->SetLineColor(kRed); // Red
+  extLowCabsCu->SetLineWidth(1);
+  extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
+  extLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
+                                            lowCablesExtPUR, medPUR);
+
+  extLowCabsPUR->SetVisibility(kTRUE);
+  extLowCabsPUR->SetLineColor(kBlack); // Black
+  extLowCabsPUR->SetLineWidth(1);
+  extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
+  extLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
+                                           hiCablesForwCu, medCu);
+
+  forwHiCabsCu->SetVisibility(kTRUE);
+  forwHiCabsCu->SetLineColor(kRed); // Red
+  forwHiCabsCu->SetLineWidth(1);
+  forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
+  forwHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
+                                            hiCablesForwPUR, medPUR);
+
+  forwHiCabsPUR->SetVisibility(kTRUE);
+  forwHiCabsPUR->SetLineColor(kBlack); // Black
+  forwHiCabsPUR->SetLineWidth(1);
+  forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
+  forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
+                                          hiCablesExtCu, medCu);
+
+  extHiCabsCu->SetVisibility(kTRUE);
+  extHiCabsCu->SetLineColor(kRed); // Red
+  extHiCabsCu->SetLineWidth(1);
+  extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
+  extHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
+                                           hiCablesExtPUR, medPUR);
+
+  extHiCabsPUR->SetVisibility(kTRUE);
+  extHiCabsPUR->SetLineColor(kBlack); // Black
+  extHiCabsPUR->SetLineWidth(1);
+  extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
+  extHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
+                                         coaxCablesForwCu, medCu);
+
+  forwCoaxCu->SetVisibility(kTRUE);
+  forwCoaxCu->SetLineColor(kRed); // Red
+  forwCoaxCu->SetLineWidth(1);
+  forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
+  forwCoaxCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *forwCoaxPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxPUR",
+                                          coaxCablesForwPUR, medPUR);
+
+  forwCoaxPUR->SetVisibility(kTRUE);
+  forwCoaxPUR->SetLineColor(kBlack); // Black
+  forwCoaxPUR->SetLineWidth(1);
+  forwCoaxPUR->SetFillColor(forwCoaxPUR->GetLineColor());
+  forwCoaxPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
+                                        coaxCablesExtCu, medCu);
+
+  extCoaxCu->SetVisibility(kTRUE);
+  extCoaxCu->SetLineColor(kRed); // Red
+  extCoaxCu->SetLineWidth(1);
+  extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
+  extCoaxCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extCoaxPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxPUR",
+                                         coaxCablesExtPUR, medPUR);
+
+  extCoaxPUR->SetVisibility(kTRUE);
+  extCoaxPUR->SetLineColor(kBlack); // Black
+  extCoaxPUR->SetLineWidth(1);
+  extCoaxPUR->SetFillColor(extCoaxPUR->GetLineColor());
+  extCoaxPUR->SetFillStyle(4000); // 0% transparent
 
 
   // Now build up the trays
@@ -3802,19 +3961,38 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   cableTrayAForw->AddNode(forwOptFibs, 1,
                      new TGeoTranslation(xloc, yloc, zloc));
 
-  xloc = lowCablesForw->GetDX() + coolTubeForw->GetRmax();
-  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +lowCablesForw->GetDY();
-  zloc = lowCablesForw->GetDZ();
-  cableTrayAForw->AddNode(forwLowCabs, 1,
+  xloc = lowCablesForwCu->GetDX() + coolTubeForw->GetRmax();
+  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
+        lowCablesForwCu->GetDY();
+  zloc = lowCablesForwCu->GetDZ();
+  cableTrayAForw->AddNode(forwLowCabsCu, 1,
+                     new TGeoTranslation(-xloc, yloc, zloc));
+  yloc += lowCablesForwCu->GetDY()+ lowCablesForwPUR->GetDY();
+  cableTrayAForw->AddNode(forwLowCabsPUR, 1,
                      new TGeoTranslation(-xloc, yloc, zloc));
 
-  xloc = hiCablesForw->GetDX() + 2*lowCablesForw->GetDX()
+  xloc = hiCablesForwCu->GetDX() + 2*lowCablesForwCu->GetDX()
        + coolTubeForw->GetRmax();
-  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + hiCablesForw->GetDY();
-  zloc = hiCablesForw->GetDZ();
-  cableTrayAForw->AddNode(forwHiCabs, 1,
+  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
+        hiCablesForwCu->GetDY();
+  zloc = hiCablesForwCu->GetDZ();
+  cableTrayAForw->AddNode(forwHiCabsCu, 1,
+                     new TGeoTranslation(-xloc, yloc, zloc));
+  yloc += hiCablesForwCu->GetDY()+ hiCablesForwPUR->GetDY();
+  cableTrayAForw->AddNode(forwHiCabsPUR, 1,
                      new TGeoTranslation(-xloc, yloc, zloc));
 
+  xloc = coaxCablesForwCu->GetDX() + 2*optFibsForw->GetDX() +
+        coolTubeForw->GetRmax();
+  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
+        coaxCablesForwCu->GetDY();
+  zloc = coaxCablesForwCu->GetDZ();
+  cableTrayAForw->AddNode(forwCoaxCu, 1,
+                     new TGeoTranslation( xloc, yloc, zloc));
+  yloc += coaxCablesForwCu->GetDY()+ coaxCablesForwPUR->GetDY();
+  cableTrayAForw->AddNode(forwCoaxPUR, 1,
+                     new TGeoTranslation( xloc, yloc, zloc));
+
   // To simplify following placement in MARS, origin is on top
   yloc = -kExternalTrayHigh + kExternalTrayThick/2;
   zloc = kExternalTrayLen/2;
@@ -3849,21 +4027,36 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   cableTrayAExt->AddNode(extCoolTube, 1,
                      new TGeoTranslation(0, yloc, zloc));
 
-  xloc = kOpticalFibersSect + coolTubeExt->GetRmax();
+  xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
   cableTrayAExt->AddNode(extOptFibs, 1,
                      new TGeoCombiTrans( xloc, 0, 0,
                                         new TGeoRotation("",90,-90,-90)));
 
-  xloc = kLowVoltageCableSect + coolTubeExt->GetRmax();
-  cableTrayAExt->AddNode(extLowCabs, 1,
+  xloc = coolTubeExt->GetRmax();
+  cableTrayAExt->AddNode(extLowCabsCu, 1,
+                     new TGeoCombiTrans(-xloc, 0, 0,
+                                        new TGeoRotation("",90,-90,-90)));
+  cableTrayAExt->AddNode(extLowCabsPUR, 1,
                      new TGeoCombiTrans(-xloc, 0, 0,
                                         new TGeoRotation("",90,-90,-90)));
 
-  xloc = 2*kHiVoltageCableSect + kLowVoltageCableSect + coolTubeExt->GetRmax();
-  cableTrayAExt->AddNode(extHiCabs, 1,
+  xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
+  cableTrayAExt->AddNode(extHiCabsCu, 1,
+                     new TGeoCombiTrans(-xloc, 0, 0,
+                                        new TGeoRotation("",90,-90,-90)));
+  cableTrayAExt->AddNode(extHiCabsPUR, 1,
                      new TGeoCombiTrans(-xloc, 0, 0,
                                         new TGeoRotation("",90,-90,-90)));
 
+  xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
+        coolTubeExt->GetRmax();
+  cableTrayAExt->AddNode(extCoaxCu, 1,
+                     new TGeoCombiTrans( xloc, 0, 0,
+                                        new TGeoRotation("",90,-90,-90)));
+  cableTrayAExt->AddNode(extCoaxPUR, 1,
+                     new TGeoCombiTrans( xloc, 0, 0,
+                                        new TGeoRotation("",90,-90,-90)));
+
 
   // Finally put everything in the mother volume
   Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
@@ -4002,9 +4195,12 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
 // Created:         ???       Bjorn S. Nilsen
 // Updated:      22 Apr 2010  Mario Sitta
 // Updated:      10 Jun 2010  Mario Sitta  Freon inside cooling pipes
+// Updated:      08 Sep 2010  Mario Sitta
 //
 // Technical data are taken from AutoCAD drawings and other (oral)
 // information given by D.Elia
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
 //
 
   // Dimensions and positions of the C-Side Cable Tray elements
@@ -4020,11 +4216,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   const Double_t kTrayCInterSpace     =   18.000 *fgkmm;//!!!TO BE CHECKED!!!
   const Double_t kTrayCFoldAngle      =    5.000 *fgkDegree;
 
-  const Double_t kCoolingTubeRmin     =    5.000 *fgkmm;
-  const Double_t kCoolingTubeRmax     =    6.000 *fgkmm;
+  const Double_t kCoolingTubeRmin     =    2.000 *fgkmm;
+  const Double_t kCoolingTubeRmax     =    3.000 *fgkmm;
   const Double_t kOpticalFibersSect   =    8.696 *fgkmm;//!!!ESTIMATED!!!
-  const Double_t kLowVoltageCableSect =    3.412 *fgkmm;//!!!ESTIMATED!!!
-  const Double_t kHiVoltageCableSect  =    1.873 *fgkmm;//!!!ESTIMATED!!!
+  const Double_t kLowVoltCableSectCu  =    7.675 *fgkmm;// Computed
+  const Double_t kLowVoltCableHighPUR =    1.000 *fgkmm;// Computed
+  const Double_t kHiVoltCableSectCu   =    1.535 *fgkmm;// Computed
+  const Double_t kHiVoltCableHighPUR  =    0.500 *fgkmm;// Computed
+  const Double_t kCoaxCableSectCu     =    6.140 *fgkmm;//!!!ESTIMATED!!!
+  const Double_t kCoaxCableHighPUR    =    1.000 *fgkmm;//!!!ESTIMATED!!!
 
   // Overall position and rotation of the C-Side Cable Trays
   const Double_t kTraySideCRPos       =   45.300 *fgkcm;
@@ -4207,8 +4407,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   optFibs->DefineSection(0, 0);
   optFibs->DefineSection(1, kOpticalFibersSect);
 
-  // The low voltage cables inside the tray: a Xtru
-  TGeoXtru *lowCables = new TGeoXtru(2);
+  // The low voltage cables inside the tray: two Xtru
+  TGeoXtru *lowCablesCu = new TGeoXtru(2);
 
   xprof[0] = sideCMidFace->GetX(5);
   yprof[0] = sideCMidFace->GetY(5);
@@ -4216,19 +4416,38 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   yprof[1] = sideCMidFace->GetY(4);
   xprof[2] = sideCMidFace->GetX(3);
   yprof[2] = sideCMidFace->GetY(3);
-  xprof[3] = xprof[2] - kLowVoltageCableSect*SinD(kTrayCFoldAngle);
-  yprof[3] = yprof[2] + kLowVoltageCableSect*CosD(kTrayCFoldAngle);
+  xprof[3] = xprof[2] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
   InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
-             kLowVoltageCableSect , xprof[4], yprof[4]);
+             kLowVoltCableSectCu , xprof[4], yprof[4]);
   xprof[5] = 0.;
-  yprof[5] = yprof[0] + kLowVoltageCableSect;
+  yprof[5] = yprof[0] + kLowVoltCableSectCu;
+
+  lowCablesCu->DefinePolygon(6, xprof, yprof);
+  lowCablesCu->DefineSection(0, 0);
+  lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
+
+  TGeoXtru *lowCablesPUR = new TGeoXtru(2);
+
+  xprof[0] = lowCablesCu->GetX(5);
+  yprof[0] = lowCablesCu->GetY(5);
+  xprof[1] = lowCablesCu->GetX(4);
+  yprof[1] = lowCablesCu->GetY(4);
+  xprof[2] = lowCablesCu->GetX(3);
+  yprof[2] = lowCablesCu->GetY(3);
+  xprof[3] = xprof[2] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kLowVoltCableHighPUR , xprof[4], yprof[4]);
+  xprof[5] = 0.;
+  yprof[5] = yprof[0] + kLowVoltCableHighPUR;
 
-  lowCables->DefinePolygon(6, xprof, yprof);
-  lowCables->DefineSection(0, 0);
-  lowCables->DefineSection(1, kLowVoltageCableSect);
+  lowCablesPUR->DefinePolygon(6, xprof, yprof);
+  lowCablesPUR->DefineSection(0, 0);
+  lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
 
-  // The high voltage cables inside the tray: a Xtru
-  TGeoXtru *hiCables = new TGeoXtru(2);
+  // The high voltage cables inside the tray: two Xtru
+  TGeoXtru *hiCablesCu = new TGeoXtru(2);
 
   xprof[0] = sideCMidFace->GetX(5);
   yprof[0] = sideCMidFace->GetY(5);
@@ -4236,16 +4455,74 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   yprof[1] = sideCMidFace->GetY(4);
   xprof[2] = sideCMidFace->GetX(3);
   yprof[2] = sideCMidFace->GetY(3);
-  xprof[3] = xprof[2] - kHiVoltageCableSect*SinD(kTrayCFoldAngle);
-  yprof[3] = yprof[2] + kHiVoltageCableSect*CosD(kTrayCFoldAngle);
+  xprof[3] = xprof[2] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kHiVoltCableSectCu , xprof[4], yprof[4]);
+  xprof[5] = 0.;
+  yprof[5] = yprof[0] + kHiVoltCableSectCu;
+
+  hiCablesCu->DefinePolygon(6, xprof, yprof);
+  hiCablesCu->DefineSection(0, 0);
+  hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
+
+  TGeoXtru *hiCablesPUR = new TGeoXtru(2);
+
+  xprof[0] = hiCablesCu->GetX(5);
+  yprof[0] = hiCablesCu->GetY(5);
+  xprof[1] = hiCablesCu->GetX(4);
+  yprof[1] = hiCablesCu->GetY(4);
+  xprof[2] = hiCablesCu->GetX(3);
+  yprof[2] = hiCablesCu->GetY(3);
+  xprof[3] = xprof[2] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
   InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
-             kHiVoltageCableSect , xprof[4], yprof[4]);
+             kHiVoltCableHighPUR , xprof[4], yprof[4]);
   xprof[5] = 0.;
-  yprof[5] = yprof[0] + kHiVoltageCableSect;
+  yprof[5] = yprof[0] + kHiVoltCableHighPUR;
 
-  hiCables->DefinePolygon(6, xprof, yprof);
-  hiCables->DefineSection(0, 0);
-  hiCables->DefineSection(1, kHiVoltageCableSect);
+  hiCablesPUR->DefinePolygon(6, xprof, yprof);
+  hiCablesPUR->DefineSection(0, 0);
+  hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
+
+  // The coaxial cables inside the tray: two Xtru
+  TGeoXtru *coaxCablesCu = new TGeoXtru(2);
+
+  xprof[0] = sideCMidFace->GetX(5);
+  yprof[0] = sideCMidFace->GetY(5);
+  xprof[1] = sideCMidFace->GetX(4);
+  yprof[1] = sideCMidFace->GetY(4);
+  xprof[2] = sideCMidFace->GetX(3);
+  yprof[2] = sideCMidFace->GetY(3);
+  xprof[3] = xprof[2] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kCoaxCableSectCu , xprof[4], yprof[4]);
+  xprof[5] = 0.;
+  yprof[5] = yprof[0] + kCoaxCableSectCu;
+
+  coaxCablesCu->DefinePolygon(6, xprof, yprof);
+  coaxCablesCu->DefineSection(0, 0);
+  coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
+
+  TGeoXtru *coaxCablesPUR = new TGeoXtru(2);
+
+  xprof[0] = coaxCablesCu->GetX(5);
+  yprof[0] = coaxCablesCu->GetY(5);
+  xprof[1] = coaxCablesCu->GetX(4);
+  yprof[1] = coaxCablesCu->GetY(4);
+  xprof[2] = coaxCablesCu->GetX(3);
+  yprof[2] = coaxCablesCu->GetY(3);
+  xprof[3] = xprof[2] - kCoaxCableHighPUR*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kCoaxCableHighPUR*CosD(kTrayCFoldAngle);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kCoaxCableHighPUR , xprof[4], yprof[4]);
+  xprof[5] = 0.;
+  yprof[5] = yprof[0] + kCoaxCableHighPUR;
+
+  coaxCablesPUR->DefinePolygon(6, xprof, yprof);
+  coaxCablesPUR->DefineSection(0, 0);
+  coaxCablesPUR->DefineSection(1, kCoaxCableSectCu);
 
 
   // We have all shapes: now create the real volumes
@@ -4253,8 +4530,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   TGeoMedium *medIn   = mgr->GetMedium("ITS_INOX$");
   TGeoMedium *medFr   = mgr->GetMedium("ITS_Freon$");
   TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
-  TGeoMedium *medLVC  = mgr->GetMedium("ITS_SPD_LOWCABLES$");
-  TGeoMedium *medHVC  = mgr->GetMedium("ITS_SPD_HICABLES$");
+  TGeoMedium *medCu   = mgr->GetMedium("ITS_COPPER$");
+  TGeoMedium *medPUR  = mgr->GetMedium("ITS_POLYURETHANE$");
 
   TGeoVolume *traySideCHorFace  = new TGeoVolume("ITSsuppSPDTraySideCHor",
                                                 sideCHorFace, medAl);
@@ -4355,23 +4632,59 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
   traySideCOptFibs->SetFillStyle(4000); // 0% transparent
 
-  TGeoVolume *traySideCLowCabs = new TGeoVolume("ITSsuppSPDTraySideCLowCabs",
-                                               lowCables, medLVC);
+  TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
+                                                 lowCablesCu, medCu);
+
+  traySideCLowCabsCu->SetVisibility(kTRUE);
+  traySideCLowCabsCu->SetLineColor(kRed); // Red
+  traySideCLowCabsCu->SetLineWidth(1);
+  traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
+  traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
+                                                  lowCablesPUR, medPUR);
+
+  traySideCLowCabsPUR->SetVisibility(kTRUE);
+  traySideCLowCabsPUR->SetLineColor(kBlack); // Black
+  traySideCLowCabsPUR->SetLineWidth(1);
+  traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
+  traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
+                                                hiCablesCu, medCu);
 
-  traySideCLowCabs->SetVisibility(kTRUE);
-  traySideCLowCabs->SetLineColor(kRed); // Red
-  traySideCLowCabs->SetLineWidth(1);
-  traySideCLowCabs->SetFillColor(traySideCLowCabs->GetLineColor());
-  traySideCLowCabs->SetFillStyle(4000); // 0% transparent
+  traySideCHiCabsCu->SetVisibility(kTRUE);
+  traySideCHiCabsCu->SetLineColor(kRed); // Red
+  traySideCHiCabsCu->SetLineWidth(1);
+  traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
+  traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
 
-  TGeoVolume *traySideCHiCabs = new TGeoVolume("ITSsuppSPDTraySideCHiCabs",
-                                              hiCables, medHVC);
+  TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
+                                                 hiCablesPUR, medPUR);
 
-  traySideCHiCabs->SetVisibility(kTRUE);
-  traySideCHiCabs->SetLineColor(kRed); // Red
-  traySideCHiCabs->SetLineWidth(1);
-  traySideCHiCabs->SetFillColor(traySideCHiCabs->GetLineColor());
-  traySideCHiCabs->SetFillStyle(4000); // 0% transparent
+  traySideCHiCabsPUR->SetVisibility(kTRUE);
+  traySideCHiCabsPUR->SetLineColor(kBlack); // Black
+  traySideCHiCabsPUR->SetLineWidth(1);
+  traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
+  traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
+                                              coaxCablesCu, medCu);
+
+  traySideCCoaxCu->SetVisibility(kTRUE);
+  traySideCCoaxCu->SetLineColor(kRed); // Red
+  traySideCCoaxCu->SetLineWidth(1);
+  traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
+  traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *traySideCCoaxPUR = new TGeoVolume("ITSsuppSPDTraySideCCoaxPUR",
+                                               coaxCablesPUR, medPUR);
+
+  traySideCCoaxPUR->SetVisibility(kTRUE);
+  traySideCCoaxPUR->SetLineColor(kBlack); // Black
+  traySideCCoaxPUR->SetLineWidth(1);
+  traySideCCoaxPUR->SetFillColor(traySideCCoaxPUR->GetLineColor());
+  traySideCCoaxPUR->SetFillStyle(4000); // 0% transparent
 
 
   // Now build up the trays
@@ -4415,13 +4728,23 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   cableTrayC->AddNode(traySideCOptFibs, 1,
                      new TGeoTranslation( 0, 0, zloc));
 
-  zloc = kLowVoltageCableSect + horTube->GetRmax();
-  cableTrayC->AddNode(traySideCLowCabs, 1,
+  zloc = kLowVoltCableSectCu + horTube->GetRmax();
+  cableTrayC->AddNode(traySideCLowCabsCu, 1,
+                     new TGeoTranslation( 0, 0,-zloc));
+  cableTrayC->AddNode(traySideCLowCabsPUR, 1,
                      new TGeoTranslation( 0, 0,-zloc));
 
-  zloc = kHiVoltageCableSect + kLowVoltageCableSect + horTube->GetRmax();
-  cableTrayC->AddNode(traySideCHiCabs, 1,
+  zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
+  cableTrayC->AddNode(traySideCHiCabsCu, 1,
                      new TGeoTranslation( 0, 0,-zloc));
+  cableTrayC->AddNode(traySideCHiCabsPUR, 1,
+                     new TGeoTranslation( 0, 0,-zloc));
+
+  zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
+  cableTrayC->AddNode(traySideCCoaxCu, 1,
+                     new TGeoTranslation( 0, 0, zloc));
+  cableTrayC->AddNode(traySideCCoaxPUR, 1,
+                     new TGeoTranslation( 0, 0, zloc));
 
 
   // Finally put everything in the mother volume
@@ -4462,6 +4785,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
 // Created:         ???       Bjorn S. Nilsen
 // Updated:       5 Jan 2010  Mario Sitta
 // Updated:      26 Feb 2010  Mario Sitta
+// Updated:      06 Sep 2010  Mario Sitta
 //
 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
 // drawings and other (oral) information given by F.Tosello
@@ -4472,12 +4796,14 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
   const Double_t kTrayARTrans            =  408.35 *fgkmm;
   const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
   const Double_t kTrayAZToSupportRing    =  435.00 *fgkmm;
-  const Double_t kExternTrayZTrans       =  853.00 *fgkmm;
+  const Double_t kExternTrayYTrans       =   96.00 *fgkmm; // Computed
+  const Double_t kExternTrayZTrans       =  823.00 *fgkmm;
   const Double_t kExternCoverYTrans      =    2.00 *fgkmm;
   const Double_t kTrayAZRot              = (180-169.5);// Degrees
   const Double_t kTrayAFirstRotAng       =   22.00;    // Degrees
   const Double_t kTrayASecondRotAng      =   15.00;    // Degrees
 
+  const Double_t kForwardTrayThick       =    2.00 *fgkmm;
   const Double_t kForwardTrayTailHeight  =  100.00 *fgkmm; // Computed
   const Double_t kForwardTrayTotalHeight =  170.00 *fgkmm; // Computed
   const Double_t kForwardTrayUpperLength =  405.00 *fgkmm; // Computed
@@ -4494,10 +4820,63 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
 
   const Int_t    kForwardTrayNpoints     =    8;
 
+  // Dimensions and positions of the Cable Tray elements
+  const Double_t kSideACoolManifWide     =    8.23 *fgkcm;
+  const Double_t kSideACoolManifHigh     =    8.06 *fgkcm;
+  const Double_t kSideACoolManifLen      =    3.90 *fgkcm;
+  const Double_t kSideACoolManifPOMFrac  =    0.0054;
+  const Double_t kSideACoolManifSteelFrac=    0.8850;
+  const Double_t kSideACoolManifWaterFrac=    0.0913;
+  const Double_t kSideACoolManifAlFrac   =    0.0183;
+
+  const Double_t kSideACoolTubesWide     =    9.07 *fgkcm;
+  const Double_t kSideACoolTubesHigh     =    1.88 *fgkcm;
+  const Double_t kSideACoolTubesTrans    =    0.88 *fgkcm;
+  const Double_t kSideACoolTubesPURFrac  =    0.5897;
+  const Double_t kSideACoolTubesWaterFrac=    0.4101;
+  const Double_t kSideACoolTubesAirFrac  =    0.0002;
+
+  const Double_t kSideAOptConnWide       =    0.90    *fgkcm;
+  const Double_t kSideAOptConnLen        =    1.37    *fgkcm;
+  const Double_t kSideAOptConnPBTFrac    =    0.5010;
+  const Double_t kSideAOptConnSteelFrac  =    0.1784;
+  const Double_t kSideAOptConnAlFrac     =    0.3206;
+
+  const Double_t kSideAOptFibsWide       =    0.71    *fgkcm;
+  const Double_t kSideAOptFibsHigh       =    3.20    *fgkcm;
+
+  const Double_t kSideAInputCablesWide   =   12.50    *fgkcm;
+  const Double_t kSideAInputCablesHigh   =    1.24    *fgkcm;
+  const Double_t kSideAInputCablesLen    =   25.20    *fgkcm;
+  const Double_t kSideAInputCablesYTrans =    1.15    *fgkcm;
+  const Double_t kSideAInputCablesCu     =    0.7404;
+  const Double_t kSideAInputCablesPlast  =    0.1269;
+  const Double_t kSideAInputCablesAl     =    0.0057;
+  const Double_t kSideAInputCablesKapton =    0.0172;
+  const Double_t kSideAInputCablesPOLYAX =    0.1098;
+
+  const Double_t kSideAOutputCablesWide  =    8.30    *fgkcm;
+  const Double_t kSideAOutputCablesHigh  =    1.56    *fgkcm;
+  const Double_t kSideAOutputCablesCu    =    0.6783;
+  const Double_t kSideAOutputCablesPlast =    0.1605;
+  const Double_t kSideAOutputCablesAl    =    0.0078;
+  const Double_t kSideAOutputCablesKapton=    0.0232;
+  const Double_t kSideAOutputCablesPOLYAX=    0.1302;
+
+  const Double_t kSideAPCBBoardsWide     =   12.50    *fgkcm;
+  const Double_t kSideAPCBBoardsHigh     =    6.32    *fgkcm;
+  const Double_t kSideAPCBBoardsLen      =   24.00    *fgkcm;
+  const Double_t kSideAPCBBoardsYTrans   =    0.75    *fgkcm;
+  const Double_t kSideAPCBBoardsCu       =    0.3864;
+  const Double_t kSideAPCBBoardsEpoxy    =    0.1486;
+  const Double_t kSideAPCBBoardsPlast    =    0.0578;
+  const Double_t kSideAPCBBoardsSteel    =    0.1521;
+  const Double_t kSideAPCBBoardsPPS      =    0.2551;
+
 
   // Local variables
   Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
-  Double_t xloc, yloc, zloc, alpharot;
+  Double_t xloc, yloc, zloc, alpharot, height;
 
 
   // The whole tray as an assembly
@@ -4507,7 +4886,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
   // First create all needed shapes
 
   // The forward tray is very complex and deserves a dedicated method
-  TGeoVolumeAssembly *forwardTray = CreateSDDForwardTraySideA(mgr);
+  CreateSDDForwardTraySideA(cableTrayA,mgr);
 
   // The forward cover: a Xtru
   TGeoXtru *forwardCover = new TGeoXtru(2);
@@ -4539,10 +4918,289 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
   // The external covers: a Composite Shape
   TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
 
+  // Now the volumes inside it
+  // The cooling manifold: four boxes
+  TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
+                kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
+                                       kSideACoolManifLen/2);
+
+  TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
+                kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
+                                         kSideACoolManifLen/2);
+
+  TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
+                kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
+                                         kSideACoolManifLen/2);
+
+  TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
+                kSideACoolManifAlFrac*kSideACoolManifHigh/2,
+                                      kSideACoolManifLen/2);
+
+  // The cooling tubes: three Xtru's
+  TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+  height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
+
+  xprof[0] = kSideACoolManifLen;
+  yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
+  xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
+            kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
+  yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
+            kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
+            kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
+  IntersectLines(              0 , xprof[0], yprof[0],
+                TanD(kTrayAZRot), xprof[2], yprof[2],
+                                  xprof[1], yprof[1]);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesPUR->DefinePolygon(6, xprof, yprof);
+  coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
+  coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
+
+  TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+  height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
+
+  xprof[0] = coolTubesPUR->GetX(5);
+  yprof[0] = coolTubesPUR->GetY(5);
+  xprof[1] = coolTubesPUR->GetX(4);
+  yprof[1] = coolTubesPUR->GetY(4);
+  xprof[2] = coolTubesPUR->GetX(3);
+  yprof[2] = coolTubesPUR->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesWater->DefinePolygon(6, xprof, yprof);
+  coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
+  coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
+
+  TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+  height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
+
+  xprof[0] = coolTubesWater->GetX(5);
+  yprof[0] = coolTubesWater->GetY(5);
+  xprof[1] = coolTubesWater->GetX(4);
+  yprof[1] = coolTubesWater->GetY(4);
+  xprof[2] = coolTubesWater->GetX(3);
+  yprof[2] = coolTubesWater->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesAir->DefinePolygon(6, xprof, yprof);
+  coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
+  coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
+
+  // The optical fiber connectors: three boxes
+  TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
+                kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
+                                     kSideAOptConnLen/2);
+
+  TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
+                kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
+                                       kSideAOptConnLen/2);
+
+  TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
+                kSideAOptConnAlFrac*kSideACoolManifHigh/2,
+                                    kSideAOptConnLen/2);
+
+  // The optical fibers: a Xtru
+  TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+  xprof[0] = kSideAOptConnLen;
+  yprof[0] = coolTubesPUR->GetY(0);
+  xprof[1] = coolTubesPUR->GetX(1);
+  yprof[1] = coolTubesPUR->GetY(1);
+  xprof[2] = coolTubesPUR->GetX(2);
+  yprof[2] = coolTubesPUR->GetY(2);
+  xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kSideAOptFibsHigh, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + kSideAOptFibsHigh;
+
+  opticalFibs->DefinePolygon(6, xprof, yprof);
+  opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
+  opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
+
+  // The input cables: five boxes
+  TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
+                  kSideAInputCablesCu*kSideAInputCablesHigh/2,
+                                      kSideAInputCablesLen/2);
+
+  TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
+                  kSideAInputCablesPlast*kSideAInputCablesHigh/2,
+                                         kSideAInputCablesLen/2);
+
+  TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
+                  kSideAInputCablesAl*kSideAInputCablesHigh/2,
+                                      kSideAInputCablesLen/2);
+
+  TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
+                  kSideAInputCablesKapton*kSideAInputCablesHigh/2,
+                                          kSideAInputCablesLen/2);
+
+  TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
+                  kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
+                                          kSideAInputCablesLen/2);
+
+  // The output cables: five Xtru
+  TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+  height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
+
+  xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
+  yprof[0] = coolTubesAir->GetY(5);
+  xprof[1] = coolTubesAir->GetX(4);
+  yprof[1] = coolTubesAir->GetY(4);
+  xprof[2] = coolTubesAir->GetX(3);
+  yprof[2] = coolTubesAir->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsCu->DefinePolygon(6, xprof, yprof);
+  outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
+  outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
+
+  TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+  height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
+
+  xprof[0] = outputCabsCu->GetX(5);
+  yprof[0] = outputCabsCu->GetY(5);
+  xprof[1] = outputCabsCu->GetX(4);
+  yprof[1] = outputCabsCu->GetY(4);
+  xprof[2] = outputCabsCu->GetX(3);
+  yprof[2] = outputCabsCu->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsPlast->DefinePolygon(6, xprof, yprof);
+  outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
+  outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
+
+  TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+  height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
+
+  xprof[0] = outputCabsPlast->GetX(5);
+  yprof[0] = outputCabsPlast->GetY(5);
+  xprof[1] = outputCabsPlast->GetX(4);
+  yprof[1] = outputCabsPlast->GetY(4);
+  xprof[2] = outputCabsPlast->GetX(3);
+  yprof[2] = outputCabsPlast->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsAl->DefinePolygon(6, xprof, yprof);
+  outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
+  outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
+
+  TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+  height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
+
+  xprof[0] = outputCabsAl->GetX(5);
+  yprof[0] = outputCabsAl->GetY(5);
+  xprof[1] = outputCabsAl->GetX(4);
+  yprof[1] = outputCabsAl->GetY(4);
+  xprof[2] = outputCabsAl->GetX(3);
+  yprof[2] = outputCabsAl->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsKapton->DefinePolygon(6, xprof, yprof);
+  outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
+  outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
+
+  TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+  height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
+
+  xprof[0] = outputCabsKapton->GetX(5);
+  yprof[0] = outputCabsKapton->GetY(5);
+  xprof[1] = outputCabsKapton->GetX(4);
+  yprof[1] = outputCabsKapton->GetY(4);
+  xprof[2] = outputCabsKapton->GetX(3);
+  yprof[2] = outputCabsKapton->GetY(3);
+  xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+  yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+  outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
+  outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
+
+  // The PCB boards: five boxes
+  TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
+                    kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
+                                      kSideAPCBBoardsLen/2);
+
+  TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
+                    kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
+                                         kSideAPCBBoardsLen/2);
+
+  TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
+                    kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
+                                         kSideAPCBBoardsLen/2);
+
+  TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
+                    kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
+                                         kSideAPCBBoardsLen/2);
+
+  TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
+                    kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
+                                       kSideAPCBBoardsLen/2);
+
 
   // We have all shapes: now create the real volumes
-  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
-  TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+  TGeoMedium *medAl     = mgr->GetMedium("ITS_ALUMINUM$");
+  TGeoMedium *medAntic  = mgr->GetMedium("ITS_ANTICORODAL$");
+  TGeoMedium *medPOM    = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+  TGeoMedium *medSteel  = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medWater  = mgr->GetMedium("ITS_WATER$");
+  TGeoMedium *medPUR    = mgr->GetMedium("ITS_POLYURETHANE$");
+  TGeoMedium *medAir    = mgr->GetMedium("ITS_AIR$");
+  TGeoMedium *medPBT    = mgr->GetMedium("ITS_PBT$");
+  TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+  TGeoMedium *medCu     = mgr->GetMedium("ITS_COPPER$");
+  TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+  TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+  TGeoMedium *medPPS    = mgr->GetMedium("ITS_PPS$");
+  TGeoMedium *medEpoxy  = mgr->GetMedium("ITS_EPOXY$");
 
   TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
                                                forwardCover, medAl);
@@ -4571,66 +5229,381 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
   externTrayCover->SetFillColor(externTrayCover->GetLineColor());
   externTrayCover->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *POMCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
+                                           coolManifPOM, medPOM);
+
+  POMCoolManif->SetVisibility(kTRUE);
+  POMCoolManif->SetLineColor(kRed); // Red
+  POMCoolManif->SetLineWidth(1);
+  POMCoolManif->SetFillColor(POMCoolManif->GetLineColor());
+  POMCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
+                                             coolManifSteel, medSteel);
+
+  SteelCoolManif->SetVisibility(kTRUE);
+  SteelCoolManif->SetLineColor(kBlue); // Blue
+  SteelCoolManif->SetLineWidth(1);
+  SteelCoolManif->SetFillColor(SteelCoolManif->GetLineColor());
+  SteelCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *WaterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
+                                             coolManifWater, medWater);
+
+  WaterCoolManif->SetVisibility(kTRUE);
+  WaterCoolManif->SetLineColor(33); // Light Blue
+  WaterCoolManif->SetLineWidth(1);
+  WaterCoolManif->SetFillColor(WaterCoolManif->GetLineColor());
+  WaterCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
+                                          coolManifAl, medAl);
+
+  AlCoolManif->SetVisibility(kTRUE);
+  AlCoolManif->SetLineColor(6); // Purple
+  AlCoolManif->SetLineWidth(1);
+  AlCoolManif->SetFillColor(AlCoolManif->GetLineColor());
+  AlCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PURCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
+                                           coolTubesPUR, medPUR);
+
+  PURCoolTubes->SetVisibility(kTRUE);
+  PURCoolTubes->SetLineColor(kRed); // Red
+  PURCoolTubes->SetLineWidth(1);
+  PURCoolTubes->SetFillColor(PURCoolTubes->GetLineColor());
+  PURCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *WaterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
+                                             coolTubesWater, medWater);
+
+  WaterCoolTubes->SetVisibility(kTRUE);
+  WaterCoolTubes->SetLineColor(33); // Light Blue
+  WaterCoolTubes->SetLineWidth(1);
+  WaterCoolTubes->SetFillColor(WaterCoolTubes->GetLineColor());
+  WaterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AirCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
+                                           coolTubesAir, medAir);
+
+  AirCoolTubes->SetVisibility(kTRUE);
+  AirCoolTubes->SetLineColor(41);
+  AirCoolTubes->SetLineWidth(1);
+  AirCoolTubes->SetFillColor(AirCoolTubes->GetLineColor());
+  AirCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PBTOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
+                                         optConnPBT, medPBT);
+
+  PBTOptConn->SetVisibility(kTRUE);
+  PBTOptConn->SetLineColor(kRed); // Red
+  PBTOptConn->SetLineWidth(1);
+  PBTOptConn->SetFillColor(PBTOptConn->GetLineColor());
+  PBTOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
+                                           optConnSteel, medSteel);
+
+  SteelOptConn->SetVisibility(kTRUE);
+  SteelOptConn->SetLineColor(kBlue); // Blue
+  SteelOptConn->SetLineWidth(1);
+  SteelOptConn->SetFillColor(SteelOptConn->GetLineColor());
+  SteelOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
+                                        optConnAl, medAl);
+
+  AlOptConn->SetVisibility(kTRUE);
+  AlOptConn->SetLineColor(6); // Purple
+  AlOptConn->SetLineWidth(1);
+  AlOptConn->SetFillColor(AlOptConn->GetLineColor());
+  AlOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *OptFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
+                                      opticalFibs, medOptFib);
+
+  OptFibs->SetVisibility(kTRUE);
+  OptFibs->SetLineColor(kOrange+2); // Orange
+  OptFibs->SetLineWidth(1);
+  OptFibs->SetFillColor(OptFibs->GetLineColor());
+  OptFibs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
+                                          inputCabsCu, medCu);
+
+  CuInputCabs->SetVisibility(kTRUE);
+  CuInputCabs->SetLineColor(kBlack); // Black
+  CuInputCabs->SetLineWidth(1);
+  CuInputCabs->SetFillColor(CuInputCabs->GetLineColor());
+  CuInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
+                                             inputCabsPlast, medPUR);
+
+  PlastInputCabs->SetVisibility(kTRUE);
+  PlastInputCabs->SetLineColor(kRed); // Red
+  PlastInputCabs->SetLineWidth(1);
+  PlastInputCabs->SetFillColor(PlastInputCabs->GetLineColor());
+  PlastInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
+                                          inputCabsAl, medAl);
+
+  AlInputCabs->SetVisibility(kTRUE);
+  AlInputCabs->SetLineColor(6); // Purple
+  AlInputCabs->SetLineWidth(1);
+  AlInputCabs->SetFillColor(AlInputCabs->GetLineColor());
+  AlInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *KaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
+                                              inputCabsKapton, medKapton);
+
+  KaptonInputCabs->SetVisibility(kTRUE);
+  KaptonInputCabs->SetLineColor(14); // 
+  KaptonInputCabs->SetLineWidth(1);
+  KaptonInputCabs->SetFillColor(KaptonInputCabs->GetLineColor());
+  KaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *POLYAXInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
+                                              inputCabsPOLYAX, medPOLYAX);
+
+  POLYAXInputCabs->SetVisibility(kTRUE);
+  POLYAXInputCabs->SetLineColor(34); // 
+  POLYAXInputCabs->SetLineWidth(1);
+  POLYAXInputCabs->SetFillColor(POLYAXInputCabs->GetLineColor());
+  POLYAXInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
+                                           outputCabsCu, medCu);
+
+  CuOutputCabs->SetVisibility(kTRUE);
+  CuOutputCabs->SetLineColor(kBlack); // Black
+  CuOutputCabs->SetLineWidth(1);
+  CuOutputCabs->SetFillColor(CuOutputCabs->GetLineColor());
+  CuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
+                                              outputCabsPlast, medPUR);
+
+  PlastOutputCabs->SetVisibility(kTRUE);
+  PlastOutputCabs->SetLineColor(kRed); // Red
+  PlastOutputCabs->SetLineWidth(1);
+  PlastOutputCabs->SetFillColor(PlastOutputCabs->GetLineColor());
+  PlastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
+                                           outputCabsAl, medAl);
+
+  AlOutputCabs->SetVisibility(kTRUE);
+  AlOutputCabs->SetLineColor(6); // Purple
+  AlOutputCabs->SetLineWidth(1);
+  AlOutputCabs->SetFillColor(AlOutputCabs->GetLineColor());
+  AlOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *KaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
+                                               outputCabsKapton, medKapton);
+
+  KaptonOutputCabs->SetVisibility(kTRUE);
+  KaptonOutputCabs->SetLineColor(14); // 
+  KaptonOutputCabs->SetLineWidth(1);
+  KaptonOutputCabs->SetFillColor(KaptonOutputCabs->GetLineColor());
+  KaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *POLYAXOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
+                                               outputCabsPOLYAX, medPOLYAX);
+
+  POLYAXOutputCabs->SetVisibility(kTRUE);
+  POLYAXOutputCabs->SetLineColor(34); // 
+  POLYAXOutputCabs->SetLineWidth(1);
+  POLYAXOutputCabs->SetFillColor(POLYAXOutputCabs->GetLineColor());
+  POLYAXOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
+                                          pcbBoardsCu, medCu);
+
+  CuPCBBoards->SetVisibility(kTRUE);
+  CuPCBBoards->SetLineColor(kBlack); // Black
+  CuPCBBoards->SetLineWidth(1);
+  CuPCBBoards->SetFillColor(CuPCBBoards->GetLineColor());
+  CuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *EpoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
+                                             pcbBoardsEpoxy, medEpoxy);
+
+  EpoxyPCBBoards->SetVisibility(kTRUE);
+  EpoxyPCBBoards->SetLineColor(22); //
+  EpoxyPCBBoards->SetLineWidth(1);
+  EpoxyPCBBoards->SetFillColor(EpoxyPCBBoards->GetLineColor());
+  EpoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
+                                             pcbBoardsPlast, medPUR);
+
+  PlastPCBBoards->SetVisibility(kTRUE);
+  PlastPCBBoards->SetLineColor(kRed); // Red
+  PlastPCBBoards->SetLineWidth(1);
+  PlastPCBBoards->SetFillColor(PlastPCBBoards->GetLineColor());
+  PlastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
+                                             pcbBoardsSteel, medSteel);
+
+  SteelPCBBoards->SetVisibility(kTRUE);
+  SteelPCBBoards->SetLineColor(kBlue); // Blue
+  SteelPCBBoards->SetLineWidth(1);
+  SteelPCBBoards->SetFillColor(SteelPCBBoards->GetLineColor());
+  SteelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PPSPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
+                                           pcbBoardsPPS, medPPS);
+
+  PPSPCBBoards->SetVisibility(kTRUE);
+  PPSPCBBoards->SetLineColor(kGreen); // Green
+  PPSPCBBoards->SetLineWidth(1);
+  PPSPCBBoards->SetFillColor(PPSPCBBoards->GetLineColor());
+  PPSPCBBoards->SetFillStyle(4000); // 0% transparent
+
 
   // Now build up the tray
-  yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) +
-        kExternTrayTotalHeight +
-        kExternCoverSideThick - kForwardTrayTailHeight;
-  zloc = kTrayAZToSupportRing - kForwardCoverLength;
+  yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
+  zloc = kForwardTrayUpperLength - kForwardCoverLength;
   cableTrayA->AddNode(forwardTrayCover, 1,
                      new TGeoTranslation( 0, yloc, zloc) );
 
   Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
                   - kExternCoverYTrans;
 
-  yloc = totalhi*(1 - CosD(kTrayAZRot));
+  yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+        kExternTrayTotalHeight*CosD(kTrayAZRot);
   zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
   cableTrayA->AddNode(externalTraySDD, 1,
                      new TGeoCombiTrans( 0, yloc, zloc,
                      new TGeoRotation("", 0,-kTrayAZRot, 0)        ) );
 
-  yloc = kExternTrayTotalHeight - kExternCoverYTrans;
-  zloc = kExternTrayZTrans - yloc*SinD(kTrayAZRot);
-  yloc *= CosD(kTrayAZRot);
-  zloc += totalhi*SinD(kTrayAZRot);
-  yloc += totalhi*(1 - CosD(kTrayAZRot));
+  yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+        kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
+  zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
   cableTrayA->AddNode(externTrayCover,1,
                      new TGeoCombiTrans( 0, yloc, zloc,
                      new TGeoRotation("", 0,-kTrayAZRot, 0)        ) );
 
+  yloc = kForwardTrayThick + coolManifPOM->GetDY();
+  zloc = coolManifPOM->GetDZ();
+  cableTrayA->AddNode(POMCoolManif, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
 
-  // Finally put everything in the mother volume
-  alpharot = -kTrayAFirstRotAng;
-  xloc = kTrayARTrans*SinD(alpharot);
-  yloc = kTrayARTrans*CosD(alpharot);
-  zloc = kTrayAZTrans;
-  moth->AddNode(cableTrayA,1,
-                           new TGeoCombiTrans( xloc, yloc, zloc,
-                           new TGeoRotation("",-alpharot,0,0)   )   );
+  yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+  cableTrayA->AddNode(SteelCoolManif, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
 
-  alpharot += 180;
-  xloc = kTrayARTrans*SinD(alpharot);
-  yloc = kTrayARTrans*CosD(alpharot);
-  moth->AddNode(cableTrayA,2,
-                           new TGeoCombiTrans( xloc, yloc, zloc,
-                           new TGeoRotation("",-alpharot,0,0)   )   );
+  yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+  cableTrayA->AddNode(WaterCoolManif, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
 
-  alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
-  xloc = kTrayARTrans*SinD(alpharot);
-  yloc = kTrayARTrans*CosD(alpharot);
-  moth->AddNode(cableTrayA,3,
-                           new TGeoCombiTrans( xloc, yloc, zloc,
-                           new TGeoRotation("",-alpharot,0,0)   )   );
+  yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+  cableTrayA->AddNode(AlCoolManif, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
 
-  alpharot += 180;
-  xloc = kTrayARTrans*SinD(alpharot);
-  yloc = kTrayARTrans*CosD(alpharot);
-  moth->AddNode(cableTrayA,4,
-                           new TGeoCombiTrans( xloc, yloc, zloc,
-                           new TGeoRotation("",-alpharot,0,0)   )   );
+  cableTrayA->AddNode(PURCoolTubes,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(WaterCoolTubes,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(AirCoolTubes,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+
+  xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
+  yloc = kForwardTrayThick + optConnPBT->GetDY();
+  zloc = optConnPBT->GetDZ();
+  cableTrayA->AddNode(PBTOptConn, 1,
+                     new TGeoTranslation( xloc, yloc, zloc) );
+  cableTrayA->AddNode(PBTOptConn, 2,
+                     new TGeoTranslation(-xloc, yloc, zloc) );
+
+  yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+  cableTrayA->AddNode(SteelOptConn, 1,
+                     new TGeoTranslation( xloc, yloc, zloc) );
+  cableTrayA->AddNode(SteelOptConn, 2,
+                     new TGeoTranslation(-xloc, yloc, zloc) );
+
+  yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+  cableTrayA->AddNode(AlOptConn, 1,
+                     new TGeoTranslation( xloc, yloc, zloc) );
+  cableTrayA->AddNode(AlOptConn, 2,
+                     new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+  xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
+  cableTrayA->AddNode(OptFibs,1,
+                     new TGeoCombiTrans( xloc, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(OptFibs,2,
+                     new TGeoCombiTrans(-xloc, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
 
-  // To avoid putting an assembly inside another assembly,
-  // the forwardTray is put directly in the mother volume
+  yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
+        kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
+  zloc = inputCabsPOLYAX->GetDZ();
+  cableTrayA->AddNode(POLYAXInputCabs, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
+  cableTrayA->AddNode(KaptonInputCabs, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
+  cableTrayA->AddNode(AlInputCabs, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
+  cableTrayA->AddNode(PlastInputCabs, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
+  cableTrayA->AddNode(CuInputCabs, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
+  zloc += pcbBoardsPPS->GetDZ();
+  cableTrayA->AddNode(PPSPCBBoards, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
+  cableTrayA->AddNode(SteelPCBBoards, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
+  cableTrayA->AddNode(PlastPCBBoards, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
+  cableTrayA->AddNode(EpoxyPCBBoards, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
+  cableTrayA->AddNode(CuPCBBoards, 1,
+                     new TGeoTranslation( 0, yloc, zloc) );
+
+  cableTrayA->AddNode(CuOutputCabs,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(PlastOutputCabs,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(AlOutputCabs,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(KaptonOutputCabs,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+  cableTrayA->AddNode(POLYAXOutputCabs,1,
+                     new TGeoCombiTrans( 0, 0, 0,
+                     new TGeoRotation("",-90, 90, 90)        ) );
+
+
+  // Finally put everything in the mother volume
   Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
                   kExternCoverSideThick -
                   kForwardTrayTailHeight;
@@ -4640,28 +5613,28 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
   yloc = rforw*CosD(alpharot);
   zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
 
-  moth->AddNode(forwardTray,1,
+  moth->AddNode(cableTrayA,1,
                            new TGeoCombiTrans( xloc, yloc, zloc,
                            new TGeoRotation("",-alpharot,0,0)   )   );
 
   alpharot += 180;
   xloc = rforw*SinD(alpharot);
   yloc = rforw*CosD(alpharot);
-  moth->AddNode(forwardTray,2,
+  moth->AddNode(cableTrayA,2,
                            new TGeoCombiTrans( xloc, yloc, zloc,
                            new TGeoRotation("",-alpharot,0,0)   )   );
 
   alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
   xloc = rforw*SinD(alpharot);
   yloc = rforw*CosD(alpharot);
-  moth->AddNode(forwardTray,3,
+  moth->AddNode(cableTrayA,3,
                            new TGeoCombiTrans( xloc, yloc, zloc,
                            new TGeoRotation("",-alpharot,0,0)   )   );
 
   alpharot += 180;
   xloc = rforw*SinD(alpharot);
   yloc = rforw*CosD(alpharot);
-  moth->AddNode(forwardTray,4,
+  moth->AddNode(cableTrayA,4,
                            new TGeoCombiTrans( xloc, yloc, zloc,
                            new TGeoRotation("",-alpharot,0,0)   )   );
 
@@ -4690,11 +5663,71 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
 // information given by F.Tosello
 //
 
-  // Dimensions and positions of the C-Side Cable Tray elements
+  // Dimensions and positions of the C-Side Cable Tray
+  // (Change accordingly to CreateSDDSSDTraysSideC !)
   const Int_t    kNumTraySideC           =    4;
 
+  const Double_t kSideCHalfThick         =    0.100   *fgkcm;
+  const Double_t kSideCLength1           =  172.800   *fgkcm;
+  const Double_t kSideCLength2           =  189.300   *fgkcm;
+  const Double_t kBarCoolRmax            =    0.4     *fgkcm;
+  const Double_t kXShiftBarCool          =   13.00    *fgkcm;
+
   const Double_t kSideCFoldAngle         =    5.00 *fgkDegree;
 
+  // Dimensions and positions of the Cable Tray elements
+  const Double_t kSideCCoolManifHalfX    =    4.25    *fgkcm;
+  const Double_t kSideCCoolManifHalfY    =    4.03    *fgkcm;
+  const Double_t kSideCCoolManifHalfZ    =    2.17    *fgkcm;
+  const Double_t kSideCCoolManifPOMFrac  =    0.0051;
+  const Double_t kSideCCoolManifSteelFrac=    0.8502;
+  const Double_t kSideCCoolManifWaterFrac=    0.0868;
+  const Double_t kSideCCoolManifAlFrac   =    0.0579;
+
+  const Double_t kSideCCoolTubesHigh     =    1.88    *fgkcm;
+  const Double_t kSideCCoolTubesTrans    =    0.85    *fgkcm;
+  const Double_t kSideCCoolTubesPURFrac  =    0.5884;
+  const Double_t kSideCCoolTubesWaterFrac=    0.4114;
+  const Double_t kSideCCoolTubesAirFrac  =    0.0002;
+
+  const Double_t kSideCOptConnHalfX      =    0.90    *fgkcm;
+  const Double_t kSideCOptConnHalfZ      =    1.37    *fgkcm;
+  const Double_t kSideCOptConnPBTFrac    =    0.6798;
+  const Double_t kSideCOptConnSteelFrac  =    0.2421;
+  const Double_t kSideCOptConnAlFrac     =    0.0781;
+
+  const Double_t kSideCOptFibsWide       =    0.71    *fgkcm;
+  const Double_t kSideCOptFibsHigh       =    3.20    *fgkcm;
+  const Double_t kSideCOptFibsTrans      =    0.20    *fgkcm;
+
+  const Double_t kSideCInputCablesLen    =   31.45    *fgkcm;
+  const Double_t kSideCInputCablesWide   =   12.50    *fgkcm;
+  const Double_t kSideCInputCablesHigh   =    0.95    *fgkcm;
+  const Double_t kSideCInputCablesTrans  =    1.15    *fgkcm;
+  const Double_t kSideCInputCablesCu     =    0.7405;
+  const Double_t kSideCInputCablesPlast  =    0.1268;
+  const Double_t kSideCInputCablesAl     =    0.0057;
+  const Double_t kSideCInputCablesKapton =    0.0172;
+  const Double_t kSideCInputCablesPOLYAX =    0.1098;
+
+  const Double_t kSideCOutputCablesX0    =   27.40    *fgkcm;
+  const Double_t kSideCOutputCablesWide  =    8.30    *fgkcm;
+  const Double_t kSideCOutputCablesHigh  =    1.18    *fgkcm;
+  const Double_t kSideCOutputCablesCu    =    0.6775;
+  const Double_t kSideCOutputCablesPlast =    0.1613;
+  const Double_t kSideCOutputCablesAl    =    0.0078;
+  const Double_t kSideCOutputCablesKapton=    0.0234;
+  const Double_t kSideCOutputCablesPOLYAX=    0.1300;
+
+  const Double_t kSideCPCBBoardsHalfX    =    6.30    *fgkcm;
+  const Double_t kSideCPCBBoardsHalfY    =    2.00    *fgkcm;
+  const Double_t kSideCPCBBoardsHalfZ    =   21.93    *fgkcm;
+  const Double_t kSideCPCBBoardsCu       =    0.3864;
+  const Double_t kSideCPCBBoardsEpoxy    =    0.1491;
+  const Double_t kSideCPCBBoardsPlast    =    0.0579;
+  const Double_t kSideCPCBBoardsSteel    =    0.1517;
+  const Double_t kSideCPCBBoardsPPS      =    0.2549;
+
   // Overall position and rotation of the C-Side Cable Trays
   const Double_t kTraySideCRPos          =   45.30    *fgkcm;
   const Double_t kTraySideCZPos          = -102.40    *fgkcm;
@@ -4703,23 +5736,629 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
 
 
   // Local variables
-//  Double_t xprof[12], yprof[12];
-  Double_t xloc, yloc, alpharot, alphafold;
+  Double_t xprof[6], yprof[6];
+  Double_t height, xloc, yloc, zloc, alpharot, alphafold;
 
 
   // The assembly holding the metallic structure
-  // We need four of them because the content is different
-  TGeoVolumeAssembly *trayStructure[kNumTraySideC];
-  for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
-    char name[20];
-    sprintf(name,"ITSsupportSDDTrayC%d",jt);
-    trayStructure[jt] = CreateSDDSSDTraysSideC(name);
-  }
+  TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
+
+  // Now the volumes inside it
+  // The cooling manifold: four boxes
+  // (X and Z are inverted on tray reference system)
+  TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
+                kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
+                                       kSideCCoolManifHalfX);
+
+  TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
+                kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
+                                         kSideCCoolManifHalfX);
+
+  TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
+                kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
+                                         kSideCCoolManifHalfX);
+
+  TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
+                kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
+                                      kSideCCoolManifHalfX);
+
+  // The cooling tubes: three Xtru's
+  alpharot = kSideCFoldAngle*TMath::DegToRad();
+
+  TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+  height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
+
+  xprof[0] = 2*kSideCCoolManifHalfZ;
+  yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
+  xprof[1] = kSideCLength1;
+  yprof[1] = yprof[0];
+  xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+  yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesPUR->DefinePolygon(6, xprof, yprof);
+  coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
+  coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
+
+  TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+  height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
+
+  xprof[0] = coolTubesPUR->GetX(5);
+  yprof[0] = coolTubesPUR->GetY(5);
+  xprof[1] = coolTubesPUR->GetX(4);
+  yprof[1] = coolTubesPUR->GetY(4);
+  xprof[2] = coolTubesPUR->GetX(3);
+  yprof[2] = coolTubesPUR->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesWater->DefinePolygon(6, xprof, yprof);
+  coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
+  coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
+
+  TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+  height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
+
+  xprof[0] = coolTubesWater->GetX(5);
+  yprof[0] = coolTubesWater->GetY(5);
+  xprof[1] = coolTubesWater->GetX(4);
+  yprof[1] = coolTubesWater->GetY(4);
+  xprof[2] = coolTubesWater->GetX(3);
+  yprof[2] = coolTubesWater->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  coolTubesAir->DefinePolygon(6, xprof, yprof);
+  coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
+  coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
+
+  // The optical fiber connectors: three boxes
+  // (X and Z are inverted on tray reference system)
+  TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
+                kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
+                                     kSideCOptConnHalfX);
+
+  TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
+                kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
+                                       kSideCOptConnHalfX);
+
+  TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
+                kSideCOptConnAlFrac*kSideCCoolManifHalfY,
+                                    kSideCOptConnHalfX);
+
+  // The optical fibers: a Xtru
+  TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+  xprof[0] = 2*kSideCOptConnHalfZ;
+  yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
+  xprof[1] = kSideCLength1;
+  yprof[1] = yprof[0];
+  xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+  yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+  xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kSideCOptFibsHigh, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + kSideCOptFibsHigh;
+
+  opticalFibs->DefinePolygon(6, xprof, yprof);
+  opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
+  opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
+
+  // The input cables: five boxes
+  // (X and Z are inverted on tray reference system)
+  TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
+                  kSideCInputCablesCu*kSideCInputCablesHigh/2,
+                                      kSideCInputCablesWide/2);
+
+  TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
+                  kSideCInputCablesPlast*kSideCInputCablesHigh/2,
+                                         kSideCInputCablesWide/2);
+
+  TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
+                  kSideCInputCablesAl*kSideCInputCablesHigh/2,
+                                      kSideCInputCablesWide/2);
+
+  TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
+                  kSideCInputCablesKapton*kSideCInputCablesHigh/2,
+                                          kSideCInputCablesWide/2);
+
+  TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
+                  kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
+                                          kSideCInputCablesWide/2);
+
+  // The output cables: five Xtru
+  TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+  height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
+
+  xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
+  yprof[0] = coolTubesAir->GetY(5);
+  xprof[1] = coolTubesAir->GetX(4);
+  yprof[1] = coolTubesAir->GetY(4);
+  xprof[2] = coolTubesAir->GetX(3);
+  yprof[2] = coolTubesAir->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsCu->DefinePolygon(6, xprof, yprof);
+  outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
+  outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
+
+  TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+  height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
+
+  xprof[0] = outputCabsCu->GetX(5);
+  yprof[0] = outputCabsCu->GetY(5);
+  xprof[1] = outputCabsCu->GetX(4);
+  yprof[1] = outputCabsCu->GetY(4);
+  xprof[2] = outputCabsCu->GetX(3);
+  yprof[2] = outputCabsCu->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsPlast->DefinePolygon(6, xprof, yprof);
+  outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
+  outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
+
+  TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+  height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
+
+  xprof[0] = outputCabsPlast->GetX(5);
+  yprof[0] = outputCabsPlast->GetY(5);
+  xprof[1] = outputCabsPlast->GetX(4);
+  yprof[1] = outputCabsPlast->GetY(4);
+  xprof[2] = outputCabsPlast->GetX(3);
+  yprof[2] = outputCabsPlast->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsAl->DefinePolygon(6, xprof, yprof);
+  outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
+  outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
+
+  TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+  height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
+
+  xprof[0] = outputCabsAl->GetX(5);
+  yprof[0] = outputCabsAl->GetY(5);
+  xprof[1] = outputCabsAl->GetX(4);
+  yprof[1] = outputCabsAl->GetY(4);
+  xprof[2] = outputCabsAl->GetX(3);
+  yprof[2] = outputCabsAl->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsKapton->DefinePolygon(6, xprof, yprof);
+  outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
+  outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
+
+  TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+  height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
+
+  xprof[0] = outputCabsKapton->GetX(5);
+  yprof[0] = outputCabsKapton->GetY(5);
+  xprof[1] = outputCabsKapton->GetX(4);
+  yprof[1] = outputCabsKapton->GetY(4);
+  xprof[2] = outputCabsKapton->GetX(3);
+  yprof[2] = outputCabsKapton->GetY(3);
+  xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+  yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             height, xprof[4], yprof[4]);
+  xprof[5] = xprof[0];
+  yprof[5] = yprof[0] + height;
+
+  outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+  outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
+  outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
+
+  // The PCB boards: five boxes
+  // (X and Z are inverted on tray reference system)
+  TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
+                    kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
+                                      kSideCPCBBoardsHalfX);
+
+  TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
+                    kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
+                                         kSideCPCBBoardsHalfX);
+
+  TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
+                    kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
+                                         kSideCPCBBoardsHalfX);
+
+  TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
+                    kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
+                                         kSideCPCBBoardsHalfX);
+
+  TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
+                    kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
+                                       kSideCPCBBoardsHalfX);
 
 
   // We have all shapes: now create the real volumes
-  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
-  if (0==1) medAl->Print();
+  TGeoMedium *medPOM    = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+  TGeoMedium *medSteel  = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medWater  = mgr->GetMedium("ITS_WATER$");
+  TGeoMedium *medAl     = mgr->GetMedium("ITS_ALUMINUM$");
+  TGeoMedium *medCu     = mgr->GetMedium("ITS_COPPER$");
+  TGeoMedium *medPUR    = mgr->GetMedium("ITS_POLYURETHANE$");
+  TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+  TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+  TGeoMedium *medAir    = mgr->GetMedium("ITS_AIR$");
+  TGeoMedium *medPBT    = mgr->GetMedium("ITS_PBT$");
+  TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+  TGeoMedium *medPPS    = mgr->GetMedium("ITS_PPS$");
+  TGeoMedium *medEpoxy  = mgr->GetMedium("ITS_EPOXY$");
+
+  TGeoVolume *POMCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
+                                           coolManifPOM, medPOM);
+
+  POMCoolManif->SetVisibility(kTRUE);
+  POMCoolManif->SetLineColor(kRed); // Red
+  POMCoolManif->SetLineWidth(1);
+  POMCoolManif->SetFillColor(POMCoolManif->GetLineColor());
+  POMCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
+                                             coolManifSteel, medSteel);
+
+  SteelCoolManif->SetVisibility(kTRUE);
+  SteelCoolManif->SetLineColor(kBlue); // Blue
+  SteelCoolManif->SetLineWidth(1);
+  SteelCoolManif->SetFillColor(SteelCoolManif->GetLineColor());
+  SteelCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *WaterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
+                                             coolManifWater, medWater);
+
+  WaterCoolManif->SetVisibility(kTRUE);
+  WaterCoolManif->SetLineColor(33); // Light Blue
+  WaterCoolManif->SetLineWidth(1);
+  WaterCoolManif->SetFillColor(WaterCoolManif->GetLineColor());
+  WaterCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
+                                          coolManifAl, medAl);
+
+  AlCoolManif->SetVisibility(kTRUE);
+  AlCoolManif->SetLineColor(6); // Purple
+  AlCoolManif->SetLineWidth(1);
+  AlCoolManif->SetFillColor(AlCoolManif->GetLineColor());
+  AlCoolManif->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PURCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
+                                           coolTubesPUR, medPUR);
+
+  PURCoolTubes->SetVisibility(kTRUE);
+  PURCoolTubes->SetLineColor(kRed); // Red
+  PURCoolTubes->SetLineWidth(1);
+  PURCoolTubes->SetFillColor(PURCoolTubes->GetLineColor());
+  PURCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *WaterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
+                                             coolTubesWater, medWater);
+
+  WaterCoolTubes->SetVisibility(kTRUE);
+  WaterCoolTubes->SetLineColor(33); // Light Blue
+  WaterCoolTubes->SetLineWidth(1);
+  WaterCoolTubes->SetFillColor(WaterCoolTubes->GetLineColor());
+  WaterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AirCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
+                                           coolTubesAir, medAir);
+
+  AirCoolTubes->SetVisibility(kTRUE);
+  AirCoolTubes->SetLineColor(41);
+  AirCoolTubes->SetLineWidth(1);
+  AirCoolTubes->SetFillColor(AirCoolTubes->GetLineColor());
+  AirCoolTubes->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PBTOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
+                                         optConnPBT, medPBT);
+
+  PBTOptConn->SetVisibility(kTRUE);
+  PBTOptConn->SetLineColor(kRed); // Red
+  PBTOptConn->SetLineWidth(1);
+  PBTOptConn->SetFillColor(PBTOptConn->GetLineColor());
+  PBTOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
+                                           optConnSteel, medSteel);
+
+  SteelOptConn->SetVisibility(kTRUE);
+  SteelOptConn->SetLineColor(kBlue); // Blue
+  SteelOptConn->SetLineWidth(1);
+  SteelOptConn->SetFillColor(SteelOptConn->GetLineColor());
+  SteelOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
+                                        optConnAl, medAl);
+
+  AlOptConn->SetVisibility(kTRUE);
+  AlOptConn->SetLineColor(6); // Purple
+  AlOptConn->SetLineWidth(1);
+  AlOptConn->SetFillColor(AlOptConn->GetLineColor());
+  AlOptConn->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *OptFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
+                                      opticalFibs, medOptFib);
+
+  OptFibs->SetVisibility(kTRUE);
+  OptFibs->SetLineColor(kOrange+2); // Orange
+  OptFibs->SetLineWidth(1);
+  OptFibs->SetFillColor(OptFibs->GetLineColor());
+  OptFibs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
+                                          inputCabsCu, medCu);
+
+  CuInputCabs->SetVisibility(kTRUE);
+  CuInputCabs->SetLineColor(kBlack); // Black
+  CuInputCabs->SetLineWidth(1);
+  CuInputCabs->SetFillColor(CuInputCabs->GetLineColor());
+  CuInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
+                                             inputCabsPlast, medPUR);
+
+  PlastInputCabs->SetVisibility(kTRUE);
+  PlastInputCabs->SetLineColor(kRed); // Red
+  PlastInputCabs->SetLineWidth(1);
+  PlastInputCabs->SetFillColor(PlastInputCabs->GetLineColor());
+  PlastInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
+                                          inputCabsAl, medAl);
+
+  AlInputCabs->SetVisibility(kTRUE);
+  AlInputCabs->SetLineColor(6); // Purple
+  AlInputCabs->SetLineWidth(1);
+  AlInputCabs->SetFillColor(AlInputCabs->GetLineColor());
+  AlInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *KaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
+                                              inputCabsKapton, medKapton);
+
+  KaptonInputCabs->SetVisibility(kTRUE);
+  KaptonInputCabs->SetLineColor(14); // 
+  KaptonInputCabs->SetLineWidth(1);
+  KaptonInputCabs->SetFillColor(KaptonInputCabs->GetLineColor());
+  KaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *POLYAXInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
+                                              inputCabsPOLYAX, medPOLYAX);
+
+  POLYAXInputCabs->SetVisibility(kTRUE);
+  POLYAXInputCabs->SetLineColor(34); // 
+  POLYAXInputCabs->SetLineWidth(1);
+  POLYAXInputCabs->SetFillColor(POLYAXInputCabs->GetLineColor());
+  POLYAXInputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
+                                           outputCabsCu, medCu);
+
+  CuOutputCabs->SetVisibility(kTRUE);
+  CuOutputCabs->SetLineColor(kBlack); // Black
+  CuOutputCabs->SetLineWidth(1);
+  CuOutputCabs->SetFillColor(CuOutputCabs->GetLineColor());
+  CuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
+                                              outputCabsPlast, medPUR);
+
+  PlastOutputCabs->SetVisibility(kTRUE);
+  PlastOutputCabs->SetLineColor(kRed); // Red
+  PlastOutputCabs->SetLineWidth(1);
+  PlastOutputCabs->SetFillColor(PlastOutputCabs->GetLineColor());
+  PlastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *AlOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
+                                           outputCabsAl, medAl);
+
+  AlOutputCabs->SetVisibility(kTRUE);
+  AlOutputCabs->SetLineColor(6); // Purple
+  AlOutputCabs->SetLineWidth(1);
+  AlOutputCabs->SetFillColor(AlOutputCabs->GetLineColor());
+  AlOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *KaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
+                                               outputCabsKapton, medKapton);
+
+  KaptonOutputCabs->SetVisibility(kTRUE);
+  KaptonOutputCabs->SetLineColor(14); // 
+  KaptonOutputCabs->SetLineWidth(1);
+  KaptonOutputCabs->SetFillColor(KaptonOutputCabs->GetLineColor());
+  KaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *POLYAXOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
+                                               outputCabsPOLYAX, medPOLYAX);
+
+  POLYAXOutputCabs->SetVisibility(kTRUE);
+  POLYAXOutputCabs->SetLineColor(34); // 
+  POLYAXOutputCabs->SetLineWidth(1);
+  POLYAXOutputCabs->SetFillColor(POLYAXOutputCabs->GetLineColor());
+  POLYAXOutputCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *CuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
+                                          pcbBoardsCu, medCu);
+
+  CuPCBBoards->SetVisibility(kTRUE);
+  CuPCBBoards->SetLineColor(kBlack); // Black
+  CuPCBBoards->SetLineWidth(1);
+  CuPCBBoards->SetFillColor(CuPCBBoards->GetLineColor());
+  CuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *EpoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
+                                             pcbBoardsEpoxy, medEpoxy);
+
+  EpoxyPCBBoards->SetVisibility(kTRUE);
+  EpoxyPCBBoards->SetLineColor(22); //
+  EpoxyPCBBoards->SetLineWidth(1);
+  EpoxyPCBBoards->SetFillColor(EpoxyPCBBoards->GetLineColor());
+  EpoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PlastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
+                                             pcbBoardsPlast, medPUR);
+
+  PlastPCBBoards->SetVisibility(kTRUE);
+  PlastPCBBoards->SetLineColor(kRed); // Red
+  PlastPCBBoards->SetLineWidth(1);
+  PlastPCBBoards->SetFillColor(PlastPCBBoards->GetLineColor());
+  PlastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *SteelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
+                                             pcbBoardsSteel, medSteel);
+
+  SteelPCBBoards->SetVisibility(kTRUE);
+  SteelPCBBoards->SetLineColor(kBlue); // Blue
+  SteelPCBBoards->SetLineWidth(1);
+  SteelPCBBoards->SetFillColor(SteelPCBBoards->GetLineColor());
+  SteelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *PPSPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
+                                           pcbBoardsPPS, medPPS);
+
+  PPSPCBBoards->SetVisibility(kTRUE);
+  PPSPCBBoards->SetLineColor(kGreen); // Green
+  PPSPCBBoards->SetLineWidth(1);
+  PPSPCBBoards->SetFillColor(PPSPCBBoards->GetLineColor());
+  PPSPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+  // Now fill the tray
+  xloc = coolManifPOM->GetDX();
+  yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
+  trayStructure->AddNode(POMCoolManif, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+  trayStructure->AddNode(SteelCoolManif, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+  trayStructure->AddNode(WaterCoolManif, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+  trayStructure->AddNode(AlCoolManif, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  xloc = inputCabsCu->GetDX();
+  yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
+        + kSideCInputCablesTrans;
+  trayStructure->AddNode(CuInputCabs, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
+  trayStructure->AddNode(PlastInputCabs, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
+  trayStructure->AddNode(AlInputCabs, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
+  trayStructure->AddNode(KaptonInputCabs, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
+  trayStructure->AddNode(POLYAXInputCabs, 1,
+                        new TGeoTranslation( xloc, yloc, 0) );
+
+  trayStructure->AddNode(PURCoolTubes  , 1, 0);
+  trayStructure->AddNode(WaterCoolTubes, 1, 0);
+  trayStructure->AddNode(AirCoolTubes  , 1, 0);
+
+  xloc = optConnPBT->GetDX();
+  yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
+  zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
+  trayStructure->AddNode(PBTOptConn, 1,
+                        new TGeoTranslation( xloc, yloc, zloc) );
+  trayStructure->AddNode(PBTOptConn, 2,
+                        new TGeoTranslation( xloc, yloc,-zloc) );
+
+  yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+  trayStructure->AddNode(SteelOptConn, 1,
+                        new TGeoTranslation( xloc, yloc, zloc) );
+  trayStructure->AddNode(SteelOptConn, 2,
+                        new TGeoTranslation( xloc, yloc,-zloc) );
+
+  yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+  trayStructure->AddNode(AlOptConn, 1,
+                        new TGeoTranslation( xloc, yloc, zloc) );
+  trayStructure->AddNode(AlOptConn, 2,
+                        new TGeoTranslation( xloc, yloc,-zloc) );
+
+  trayStructure->AddNode(OptFibs, 1,
+                        new TGeoTranslation( 0, 0, zloc) );
+  trayStructure->AddNode(OptFibs, 2,
+                        new TGeoTranslation( 0, 0,-zloc) );
+
+  trayStructure->AddNode(CuOutputCabs    , 1, 0);
+  trayStructure->AddNode(PlastOutputCabs , 1, 0);
+  trayStructure->AddNode(AlOutputCabs    , 1, 0);
+  trayStructure->AddNode(KaptonOutputCabs, 1, 0);
+  trayStructure->AddNode(POLYAXOutputCabs, 1, 0);
+
+  xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
+  yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
+  trayStructure->AddNode(CuPCBBoards, 1,
+                        new TGeoTranslation( xloc, yloc , 0) );
+
+  yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
+  trayStructure->AddNode(EpoxyPCBBoards, 1,
+                        new TGeoTranslation( xloc, yloc , 0) );
+
+  yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
+  trayStructure->AddNode(PlastPCBBoards, 1,
+                        new TGeoTranslation( xloc, yloc , 0) );
+
+  yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
+  trayStructure->AddNode(SteelPCBBoards, 1,
+                        new TGeoTranslation( xloc, yloc , 0) );
+
+  yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
+  trayStructure->AddNode(PPSPCBBoards, 1,
+                        new TGeoTranslation( xloc, yloc , 0) );
+
 
   // Finally put everything in the mother volume
   alphafold = kSideCFoldAngle;
@@ -4728,7 +6367,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
     alpharot = kTraySideCAlphaRot[jt];
     xloc = kTraySideCRPos*SinD(alpharot);
     yloc = kTraySideCRPos*CosD(alpharot);
-    moth->AddNode(trayStructure[jt],1,
+    moth->AddNode(trayStructure,jt+1,
                       new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
                       new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
   }
@@ -5480,18 +7119,21 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
 }
 
 //______________________________________________________________________
-TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoManager *mgr){
+void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
+                                                        TGeoManager *mgr){
 //
 // Creates the forward SDD tray on Side A (0872/G/D/01)
 //
 // Input:
+//         tray : the TGeoVolumeAssembly to put the elements in
 //         mgr  : the GeoManager (used only to get the proper material)
 //
 // Output:
 //
-// Return:     a TGeoVolumeAssembly for the tray
+// Return:
 //
 // Created:      08 Jan 2010  Mario Sitta
+// Updated:      07 Sep 2010  Mario Sitta
 //
 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
 // drawings and other (oral) information given by F.Tosello
@@ -5525,9 +7167,7 @@ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoMana
 
 
   // The tray has a very complex shape, so it is made by assembling
-  // different elements (with some small simplifications): the result
-  // is a TGeoAssembly returned to the caller
-  TGeoVolumeAssembly *forwardTray = new TGeoVolumeAssembly("ITSsuppSDDForwardTray");
+  // different elements (with some small simplifications)
 
   // The tray base: a BBox
   zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
@@ -5664,53 +7304,53 @@ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoMana
   // Now build up the tray
   yloc = kForwardTrayThick/2;
   zloc = zlen;
-  forwardTray->AddNode(forwTrayBase, 1,
-                      new TGeoTranslation(0, yloc, zloc) );
+  tray->AddNode(forwTrayBase, 1,
+               new TGeoTranslation(0, yloc, zloc) );
 
   xloc = kForwardTrayBaseHalfWide;
-  forwardTray->AddNode(forwTraySide1, 1,
-                      new TGeoCombiTrans(xloc, 0, 0,
+  tray->AddNode(forwTraySide1, 1,
+               new TGeoCombiTrans(xloc, 0, 0,
                                   new TGeoRotation("",90,-90,-90)));
   xloc = -xloc + kForwardTrayThick;
-  forwardTray->AddNode(forwTraySide1, 2,
-                      new TGeoCombiTrans(xloc, 0, 0,
+  tray->AddNode(forwTraySide1, 2,
+               new TGeoCombiTrans(xloc, 0, 0,
                                   new TGeoRotation("",90,-90,-90)));
 
-  forwardTray->AddNode(forwTraySide2, 1, 0);
+  tray->AddNode(forwTraySide2, 1, 0);
   zloc = kForwardTraySideLength;
-  forwardTray->AddNode(forwTraySide2, 2,
-                      new TGeoCombiTrans(0, 0, zloc,
+  tray->AddNode(forwTraySide2, 2,
+               new TGeoCombiTrans(0, 0, zloc,
                                   new TGeoRotation("",90,-180,-90)));
 
   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
-  forwardTray->AddNode(forwTraySide3, 1,
-                      new TGeoCombiTrans(xloc, 0, 0,
+  tray->AddNode(forwTraySide3, 1,
+               new TGeoCombiTrans(xloc, 0, 0,
                                   new TGeoRotation("",90,-90,-90)));
   xloc = -xloc + kForwardTrayThick;
-  forwardTray->AddNode(forwTraySide3, 2,
-                      new TGeoCombiTrans(xloc, 0, 0,
+  tray->AddNode(forwTraySide3, 2,
+               new TGeoCombiTrans(xloc, 0, 0,
                                   new TGeoRotation("",90,-90,-90)));
 
   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
        - kForwardTrayHorWingWide/2;
   yloc = traySide3->GetY(2) + kForwardTrayThick/2;
   zloc = kForwardTraySideLength - trayHorWing->GetDZ();
-  forwardTray->AddNode(forwTrayHWing, 1,
-                      new TGeoTranslation( xloc, yloc, zloc) );
-  forwardTray->AddNode(forwTrayHWing, 2,
-                      new TGeoTranslation(-xloc, yloc, zloc) );
+  tray->AddNode(forwTrayHWing, 1,
+               new TGeoTranslation( xloc, yloc, zloc) );
+  tray->AddNode(forwTrayHWing, 2,
+               new TGeoTranslation(-xloc, yloc, zloc) );
 
   xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
        - kForwardTrayVertWingWide/2;
   yloc = traySide3->GetY(2) + trayVertWing->GetDY();
   zloc = traySide3->GetX(3) + kForwardTrayThick/2;
-  forwardTray->AddNode(forwTrayVWing, 1,
-                      new TGeoTranslation( xloc, yloc, zloc) );
-  forwardTray->AddNode(forwTrayVWing, 2,
-                      new TGeoTranslation(-xloc, yloc, zloc) );
+  tray->AddNode(forwTrayVWing, 1,
+               new TGeoTranslation( xloc, yloc, zloc) );
+  tray->AddNode(forwTrayVWing, 2,
+               new TGeoTranslation(-xloc, yloc, zloc) );
 
 
-  return forwardTray;
+  return;
 }
 
 //______________________________________________________________________
index d776625..615f779 100644 (file)
@@ -65,7 +65,7 @@ class AliITSv11GeometrySupport : public AliITSv11Geometry {
     void SSDCableTraysSideA(TGeoVolume *moth, TGeoManager *mgr=gGeoManager);
     void SSDCableTraysSideC(TGeoVolume *moth, TGeoManager *mgr=gGeoManager);
 
-    TGeoVolumeAssembly* CreateSDDForwardTraySideA(TGeoManager *mgr);
+    void CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray, TGeoManager *mgr);
 
     TGeoCompositeShape* CreateTrayAForwardCover(const Double_t coverLen);
     TGeoCompositeShape* CreateTrayAExternalCover(const Double_t coverLen);
index e055673..cba1201 100644 (file)
@@ -5443,6 +5443,24 @@ void AliITSv11Hybrid::CreateMaterials(){
     Float_t wPVC[3] = {  2.    , 3.     ,  1.   };
     Float_t dPVC    = 1.3;
 
+    // PBT (Polybutylene terephthalate = C12-H12-O4) - 01 Sep 10
+    Float_t aPBT[3] = { 12.0107, 1.00794, 15.9994};
+    Float_t zPBT[3] = {  6.    , 1.     ,  8.   };
+    Float_t wPBT[3] = { 12.    ,12.     ,  4.   };
+    Float_t dPBT    = 1.31;
+
+    // POLYAX (POLYAX = C37-H24-O6-N2) - 03 Sep 10
+    Float_t aPOLYAX[4] = { 12.0107, 1.00794, 15.9994, 14.00674};
+    Float_t zPOLYAX[4] = {  6.    , 1.     ,  8.    ,  7.     };
+    Float_t wPOLYAX[4] = { 37.    ,24.     ,  6.    ,  2.     };
+    Float_t dPOLYAX    = 1.27;
+
+    // PPS (PPS = C6-H4-S) - 05 Sep 10
+    Float_t aPPS[3] = { 12.0107, 1.00794, 32.066};
+    Float_t zPPS[3] = {  6.    , 1.     , 16.   };
+    Float_t wPPS[3] = {  6.    , 4.     ,  1.   };
+    Float_t dPPS    = 1.35;
+
     //SSD NiSn capacitor ends
     Float_t aNiSn[2]  = { 56.6934,118.710};
     Float_t zNiSn[2]  = {     28.,     50.};
@@ -5505,6 +5523,15 @@ void AliITSv11Hybrid::CreateMaterials(){
     AliMixture(27,"GEN Air$",aAir,zAir,dAir,4,wAir);
     AliMedium(27,"GEN Air$",27,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,epsilAir,stminAir);
 
+    AliMixture(44,"PPS$",aPPS,zPPS,dPPS,-3,wPPS);
+    AliMedium(44,"PPS$",44,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
+
+    AliMixture(45,"POLYAX$",aPOLYAX,zPOLYAX,dPOLYAX,-4,wPOLYAX);
+    AliMedium(45,"POLYAX$",45,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
+
+    AliMixture(46,"PBT$",aPBT,zPBT,dPBT,-3,wPBT);
+    AliMedium(46,"PBT$",46,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
+
     AliMixture(47,"PVC$",aPVC,zPVC,dPVC,-3,wPVC);
     AliMedium(47,"PVC$",47,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);