update to AOD analysis

[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySupport.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

// This class Defines the Geometry for the ITS services and support cones
// outside of the ceneteral volume (except for the Ceneteral support 
// cylinders. Other classes define the rest of the ITS. Specificaly the ITS
// The SSD support cone,SSD Support centeral cylinder, SDD support cone,
// The SDD cupport centeral cylinder, the SPD Thermal Sheald, The supports
// and cable trays on both the RB26 (muon dump) and RB24 sides, and all of
// the cabling from the ladders/stave ends out past the TPC. 

/* $Id$ */
// General Root includes
#include <TMath.h>
// Root Geometry includes
//#include <AliLog.h>
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TGeoPcon.h>
#include <TGeoCone.h>
#include <TGeoTube.h> // contaings TGeoTubeSeg
#include <TGeoArb8.h>
#include <TGeoXtru.h>
#include <TGeoCompositeShape.h>
#include <TGeoMatrix.h>
#include "AliITSv11GeometrySupport.h"

ClassImp(AliITSv11GeometrySupport)

#define SQ(A) (A)*(A)

//______________________________________________________________________
void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SPD thermal shield as a volume assembly
// and adds it to the mother volume
// (this is actually a merge of the previous SPDThermalSheald method
// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06 and the
// CreateSPDThermalShield method of AliITSv11Hybrid)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???          ???
// Updated:      11 Dec 2007  Mario Sitta
//
// Technical data are taken from:  ALICE-Thermal Screen "Cone transition"
// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)


  // Dimensions of the Central shield
  const Double_t kHalfLengthCentral  = 399.9*fgkmm;
  const Double_t kThicknessCentral   = 0.4*fgkmm;
  const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
  const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
  const Double_t kInnerACentral = 3.1674*fgkcm;
  const Double_t kInnerBCentral = 2.023 *fgkcm;
  const Double_t kOuterACentral = 2.4374*fgkcm;
  const Double_t kOuterBCentral = 3.8162*fgkcm;
  // Dimensions of the EndCap shield
  const Double_t kHalfLengthEndCap  = 25.*fgkmm;
  const Double_t kThicknessEndCap   = 2.0*fgkmm;
  const Double_t kInnerRadiusEndCap = 8.0775*fgkcm;
  const Double_t kOuterRadiusEndCap = 9.9955*fgkcm;
  const Double_t kInnerAEndCap = 3.1453*fgkcm;
  const Double_t kInnerBEndCap = 2.0009*fgkcm;
  const Double_t kOuterAEndCap = 2.4596*fgkcm;
  const Double_t kOuterBEndCap = 3.8384*fgkcm;
  // Dimensions of the Cone shield
  const Double_t kHalfLengthCone  = 145.*fgkmm;
  const Double_t kThicknessCone   = 0.3*fgkmm;
  const Double_t kInnerRadialCone = 37.3*fgkcm;
  const Double_t kOuterRadialCone = 39.0*fgkcm;
  const Double_t kInnerACone = 14.2344*fgkcm;
  const Double_t kInnerBCone =  9.0915*fgkcm;
  const Double_t kOuterACone =  9.5058*fgkcm;
  const Double_t kOuterBCone = 14.8831*fgkcm;
  // Dimensions of the Flange's Ring and Wing
  const Double_t kHalfLengthRing  = 7.5*fgkmm;
  const Double_t kThicknessRing   = 0.3*fgkmm;
  const Double_t kInnerRadiusRing = 37.3*fgkcm;
  const Double_t kOuterRadiusRing = 42.0*fgkcm;
  const Double_t kOuterRadiusWing = 49.25*fgkcm;
  const Double_t kWideWing      = 6.0*fgkcm;
  const Double_t kThetaWing     = 45.0;
  // Common data
  const Double_t kTheta = 36.0*TMath::DegToRad();
  const Double_t kThicknessOmega = 0.3*fgkmm;

  // Local variables
  Double_t zpos;
  Double_t xshld[24], yshld[24];
  Double_t xair[24] , yair[24];  // Coord. of whole air shape
  Double_t xair1[4] , yair1[4];  // Coord. of every single air volume
  Double_t xomega[48], yomega[48];
  //  Double_t *xyarb8;

  // The entire shield is made up of two half central shields
  // symmetric with respect to the XZ plane, four half end cap
  // shields, again symmetric with respect to the XZ plane, and four
  // half cones, symmetric with respect to the XZ plane too.

  TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");

  // The central half shield: a half tube of carbon fiber,
  // filled with air volumes, which together make the whole shield
  // (i.e. the tube and the Omega-shaped insert).
  // They are all XTru shapes

  TGeoXtru *centralshape = new TGeoXtru(2);

  CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
			kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
			kTheta,xshld,yshld);

  centralshape->DefinePolygon(24,xshld,yshld);
  centralshape->DefineSection(0,-kHalfLengthCentral);
  centralshape->DefineSection(1, kHalfLengthCentral);

  // Now rescale to get the air volume dimensions
    InsidePoint(xshld[23], yshld[23],
		xshld[ 0], yshld[ 0],
		xshld[ 1], yshld[ 1], kThicknessCentral,
		xair[0], yair[0]);
  for (Int_t i=1; i<23; i++) {
    InsidePoint(xshld[i-1], yshld[i-1],
		xshld[ i ], yshld[ i ],
		xshld[i+1], yshld[i+1], kThicknessCentral,
		xair[i], yair[i]);
  }
    InsidePoint(xshld[22], yshld[22],
		xshld[23], yshld[23],
		xshld[ 0], yshld[ 0], kThicknessCentral,
		xair[23], yair[23]);

  // Then use them to determine the Omega shape points
  CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);

  // Finally create the single air volumes
  TGeoXtru *centralair1shape = new TGeoXtru(2);

  xair1[0] = xomega[1];
  yair1[0] = yomega[1];
  xair1[1] = xomega[0];
  yair1[1] = yomega[0];
  xair1[2] = -xair1[1];
  yair1[2] =  yair1[1];
  xair1[3] = -xair1[0];
  yair1[3] =  yair1[0];

  centralair1shape->DefinePolygon(4,xair1,yair1);
  centralair1shape->DefineSection(0,-kHalfLengthCentral);
  centralair1shape->DefineSection(1, kHalfLengthCentral);

  TGeoXtru *centralair2shape = new TGeoXtru(2);

  xair1[0] = xomega[21];
  yair1[0] = yomega[21];
  xair1[1] = xomega[20];
  yair1[1] = yomega[20];
  xair1[2] = xomega[23];
  yair1[2] = yomega[23];
  xair1[3] = xomega[22];
  yair1[3] = yomega[22];

  centralair2shape->DefinePolygon(4,xair1,yair1);
  centralair2shape->DefineSection(0,-kHalfLengthCentral);
  centralair2shape->DefineSection(1, kHalfLengthCentral);

  TGeoXtru *centralair3shape = new TGeoXtru(2);

  xair1[0] = xomega[2];
  yair1[0] = yomega[2];
  xair1[1] = xomega[3];
  yair1[1] = yomega[3];
  xair1[2] = xomega[4];
  yair1[2] = yomega[4];
  xair1[3] = xomega[5];
  yair1[3] = yomega[5];

  centralair3shape->DefinePolygon(4,xair1,yair1);
  centralair3shape->DefineSection(0,-kHalfLengthCentral);
  centralair3shape->DefineSection(1, kHalfLengthCentral);

  TGeoXtru *centralair4shape = new TGeoXtru(2);

  xair1[0] = xomega[16];
  yair1[0] = yomega[16];
  xair1[1] = xomega[17];
  yair1[1] = yomega[17];
  xair1[2] = xomega[18];
  yair1[2] = yomega[18];
  xair1[3] = xomega[19];
  yair1[3] = yomega[19];

  centralair4shape->DefinePolygon(4,xair1,yair1);
  centralair4shape->DefineSection(0,-kHalfLengthCentral);
  centralair4shape->DefineSection(1, kHalfLengthCentral);

  TGeoXtru *centralair5shape = new TGeoXtru(2);

  xair1[0] = xomega[6];
  yair1[0] = yomega[6];
  xair1[1] = xomega[7];
  yair1[1] = yomega[7];
  xair1[2] = xomega[8];
  yair1[2] = yomega[8];
  xair1[3] = xomega[9];
  yair1[3] = yomega[9];

  centralair5shape->DefinePolygon(4,xair1,yair1);
  centralair5shape->DefineSection(0,-kHalfLengthCentral);
  centralair5shape->DefineSection(1, kHalfLengthCentral);

  TGeoXtru *centralair6shape = new TGeoXtru(2);

  xair1[0] = xomega[12];
  yair1[0] = yomega[12];
  xair1[1] = xomega[13];
  yair1[1] = yomega[13];
  xair1[2] = xomega[14];
  yair1[2] = yomega[14];
  xair1[3] = xomega[15];
  yair1[3] = yomega[15];

  centralair6shape->DefinePolygon(4,xair1,yair1);
  centralair6shape->DefineSection(0,-kHalfLengthCentral);
  centralair6shape->DefineSection(1, kHalfLengthCentral);


  // The end cap half shield: a half tube of carbon fiber,
  // filled with air volumes, which together make the whole shield
  // (i.e. the tube and the Omega-shaped insert).
  // They are all XTru shapes

  TGeoXtru *endcapshape = new TGeoXtru(2);

  CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
			kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
			kTheta,xshld,yshld);

  endcapshape->DefinePolygon(24,xshld,yshld);
  endcapshape->DefineSection(0,-kHalfLengthEndCap);
  endcapshape->DefineSection(1, kHalfLengthEndCap);

  // Now rescale to get the air volume dimensions
    InsidePoint(xshld[23], yshld[23],
		xshld[ 0], yshld[ 0],
		xshld[ 1], yshld[ 1], kThicknessEndCap,
		xair[0], yair[0]);
  for (Int_t i=1; i<23; i++) {
    InsidePoint(xshld[i-1], yshld[i-1],
		xshld[ i ], yshld[ i ],
		xshld[i+1], yshld[i+1], kThicknessEndCap,
		xair[i], yair[i]);
  }
    InsidePoint(xshld[22], yshld[22],
		xshld[23], yshld[23],
		xshld[ 0], yshld[ 0], kThicknessEndCap,
		xair[23], yair[23]);

  // Then use them to determine the Omega shape points
  CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);

  // Finally create the single air volumes
  TGeoXtru *endcapair1shape = new TGeoXtru(2);

  xair1[0] = xomega[1];
  yair1[0] = yomega[1];
  xair1[1] = xomega[0];
  yair1[1] = yomega[0];
  xair1[2] = -xair1[1];
  yair1[2] =  yair1[1];
  xair1[3] = -xair1[0];
  yair1[3] =  yair1[0];

  endcapair1shape->DefinePolygon(4,xair1,yair1);
  endcapair1shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair1shape->DefineSection(1, kHalfLengthEndCap);

  TGeoXtru *endcapair2shape = new TGeoXtru(2);

  xair1[0] = xomega[21];
  yair1[0] = yomega[21];
  xair1[1] = xomega[20];
  yair1[1] = yomega[20];
  xair1[2] = xomega[23];
  yair1[2] = yomega[23];
  xair1[3] = xomega[22];
  yair1[3] = yomega[22];

  endcapair2shape->DefinePolygon(4,xair1,yair1);
  endcapair2shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair2shape->DefineSection(1, kHalfLengthEndCap);

  TGeoXtru *endcapair3shape = new TGeoXtru(2);

  xair1[0] = xomega[2];
  yair1[0] = yomega[2];
  xair1[1] = xomega[3];
  yair1[1] = yomega[3];
  xair1[2] = xomega[4];
  yair1[2] = yomega[4];
  xair1[3] = xomega[5];
  yair1[3] = yomega[5];

  endcapair3shape->DefinePolygon(4,xair1,yair1);
  endcapair3shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair3shape->DefineSection(1, kHalfLengthEndCap);

  TGeoXtru *endcapair4shape = new TGeoXtru(2);

  xair1[0] = xomega[16];
  yair1[0] = yomega[16];
  xair1[1] = xomega[17];
  yair1[1] = yomega[17];
  xair1[2] = xomega[18];
  yair1[2] = yomega[18];
  xair1[3] = xomega[19];
  yair1[3] = yomega[19];

  endcapair4shape->DefinePolygon(4,xair1,yair1);
  endcapair4shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair4shape->DefineSection(1, kHalfLengthEndCap);

  TGeoXtru *endcapair5shape = new TGeoXtru(2);

  xair1[0] = xomega[6];
  yair1[0] = yomega[6];
  xair1[1] = xomega[7];
  yair1[1] = yomega[7];
  xair1[2] = xomega[8];
  yair1[2] = yomega[8];
  xair1[3] = xomega[9];
  yair1[3] = yomega[9];

  endcapair5shape->DefinePolygon(4,xair1,yair1);
  endcapair5shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair5shape->DefineSection(1, kHalfLengthEndCap);

  TGeoXtru *endcapair6shape = new TGeoXtru(2);

  xair1[0] = xomega[12];
  yair1[0] = yomega[12];
  xair1[1] = xomega[13];
  yair1[1] = yomega[13];
  xair1[2] = xomega[14];
  yair1[2] = yomega[14];
  xair1[3] = xomega[15];
  yair1[3] = yomega[15];

  endcapair6shape->DefinePolygon(4,xair1,yair1);
  endcapair6shape->DefineSection(0,-kHalfLengthEndCap);
  endcapair6shape->DefineSection(1, kHalfLengthEndCap);

  // The cone half shield is more complex since there is no basic
  // TGeo shape to describe it correctly. So it is made of a series
  // of TGeoArb8 shapes filled with air, which all together make up the
  // the cone AND its internal insert. Part of the following code is
  // adapted from SPDThermalSheald method.

  // sCn : Filled portions, sChn : Air holes
  TGeoArb8 *sC1  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC2  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC3  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC4  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC5  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC6  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC7  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC8  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC9  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone);

  sC1->SetName("sC1");
  sC2->SetName("sC2");
  sC3->SetName("sC3");
  sC4->SetName("sC4");
  sC5->SetName("sC5");
  sC6->SetName("sC6");
  sC7->SetName("sC7");
  sC8->SetName("sC8");
  sC9->SetName("sC9");
  sC10->SetName("sC10");
  sC11->SetName("sC11");

  TGeoArb8 *sCh1  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh2  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh3  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh4  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh5  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh6  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh7  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh8  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh9  = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone);
  TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone);

  sCh1->SetName("sCh1");
  sCh2->SetName("sCh2");
  sCh3->SetName("sCh3");
  sCh4->SetName("sCh4");
  sCh5->SetName("sCh5");
  sCh6->SetName("sCh6");
  sCh7->SetName("sCh7");
  sCh8->SetName("sCh8");
  sCh9->SetName("sCh9");
  sCh10->SetName("sCh10");
  sCh11->SetName("sCh11");

  // Smaller end: determine the coordinates of the points of carbon fiber
  CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
			kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
			kTheta,xshld,yshld);

  sC1->SetVertex(0, xshld[12], yshld[12]);
  sC1->SetVertex(1, xshld[11], yshld[11]);
  sC1->SetVertex(2, xshld[ 0], yshld[ 0]);
  sC1->SetVertex(3, xshld[23], yshld[23]);

  sC2->SetVertex(0, xshld[11], yshld[11]);
  sC2->SetVertex(1, xshld[10], yshld[10]);
  sC2->SetVertex(2, xshld[ 1], yshld[ 1]);
  sC2->SetVertex(3, xshld[ 0], yshld[ 0]);

  sC3->SetVertex(0, xshld[10], yshld[10]);
  sC3->SetVertex(1, xshld[ 9], yshld[ 9]);
  sC3->SetVertex(2, xshld[ 2], yshld[ 2]);
  sC3->SetVertex(3, xshld[ 1], yshld[ 1]);

  sC4->SetVertex(0, xshld[ 9], yshld[ 9]);
  sC4->SetVertex(1, xshld[ 8], yshld[ 8]);
  sC4->SetVertex(2, xshld[ 3], yshld[ 3]);
  sC4->SetVertex(3, xshld[ 2], yshld[ 2]);

  sC5->SetVertex(0, xshld[ 8], yshld[ 8]);
  sC5->SetVertex(1, xshld[ 7], yshld[ 7]);
  sC5->SetVertex(2, xshld[ 4], yshld[ 4]);
  sC5->SetVertex(3, xshld[ 3], yshld[ 3]);

  sC6->SetVertex(0, xshld[ 7], yshld[ 7]);
  sC6->SetVertex(1, xshld[ 6], yshld[ 6]);
  sC6->SetVertex(2, xshld[ 5], yshld[ 5]);
  sC6->SetVertex(3, xshld[ 4], yshld[ 4]);

  sC7->SetVertex(0,-xshld[10], yshld[10]);
  sC7->SetVertex(1,-xshld[11], yshld[11]);
  sC7->SetVertex(2,-xshld[ 0], yshld[ 0]);
  sC7->SetVertex(3,-xshld[ 1], yshld[ 1]);

  sC8->SetVertex(0,-xshld[ 9], yshld[ 9]);
  sC8->SetVertex(1,-xshld[10], yshld[10]);
  sC8->SetVertex(2,-xshld[ 1], yshld[ 1]);
  sC8->SetVertex(3,-xshld[ 2], yshld[ 2]);

  sC9->SetVertex(0,-xshld[ 8], yshld[ 8]);
  sC9->SetVertex(1,-xshld[ 9], yshld[ 9]);
  sC9->SetVertex(2,-xshld[ 2], yshld[ 2]);
  sC9->SetVertex(3,-xshld[ 3], yshld[ 3]);

  sC10->SetVertex(0,-xshld[ 7], yshld[ 7]);
  sC10->SetVertex(1,-xshld[ 8], yshld[ 8]);
  sC10->SetVertex(2,-xshld[ 3], yshld[ 3]);
  sC10->SetVertex(3,-xshld[ 4], yshld[ 4]);

  sC11->SetVertex(0,-xshld[ 6], yshld[ 6]);
  sC11->SetVertex(1,-xshld[ 7], yshld[ 7]);
  sC11->SetVertex(2,-xshld[ 4], yshld[ 4]);
  sC11->SetVertex(3,-xshld[ 5], yshld[ 5]);

  // Then rescale to get the air volume dimensions
    InsidePoint(xshld[23], yshld[23],
		xshld[ 0], yshld[ 0],
		xshld[ 1], yshld[ 1], kThicknessCone,
		xair[0], yair[0]);
  for (Int_t i=1; i<23; i++) {
    InsidePoint(xshld[i-1], yshld[i-1],
		xshld[ i ], yshld[ i ],
		xshld[i+1], yshld[i+1], kThicknessCone,
		xair[i], yair[i]);
  }
    InsidePoint(xshld[22], yshld[22],
		xshld[23], yshld[23],
		xshld[ 0], yshld[ 0], kThicknessCone,
		xair[23], yair[23]);

  // Then use them to determine the Omega shape points
  CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);

  // Finally fill the small end coordinates of the air shapes
  sCh1->SetVertex(0, xomega[ 0], yomega[ 0]);
  sCh1->SetVertex(1, xomega[ 1], yomega[ 1]);
  sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]);
  sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]);

  sCh2->SetVertex(0, xomega[20], yomega[20]);
  sCh2->SetVertex(1, xomega[21], yomega[21]);
  sCh2->SetVertex(2, xomega[22], yomega[22]);
  sCh2->SetVertex(3, xomega[23], yomega[23]);

  sCh3->SetVertex(0, xomega[ 2], yomega[ 2]);
  sCh3->SetVertex(1, xomega[ 3], yomega[ 3]);
  sCh3->SetVertex(2, xomega[ 4], yomega[ 4]);
  sCh3->SetVertex(3, xomega[ 5], yomega[ 5]);

  sCh4->SetVertex(0, xomega[16], yomega[16]);
  sCh4->SetVertex(1, xomega[17], yomega[17]);
  sCh4->SetVertex(2, xomega[18], yomega[18]);
  sCh4->SetVertex(3, xomega[19], yomega[19]);

  sCh5->SetVertex(0, xomega[ 6], yomega[ 6]);
  sCh5->SetVertex(1, xomega[ 7], yomega[ 7]);
  sCh5->SetVertex(2, xomega[ 8], yomega[ 8]);
  sCh5->SetVertex(3, xomega[ 9], yomega[ 9]);

  sCh6->SetVertex(0, xomega[12], yomega[12]);
  sCh6->SetVertex(1, xomega[13], yomega[13]);
  sCh6->SetVertex(2, xomega[14], yomega[14]);
  sCh6->SetVertex(3, xomega[15], yomega[15]);

  sCh7->SetVertex(0,-xomega[21], yomega[21]);
  sCh7->SetVertex(1,-xomega[20], yomega[20]);
  sCh7->SetVertex(2,-xomega[23], yomega[23]);
  sCh7->SetVertex(3,-xomega[22], yomega[22]);

  sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]);
  sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]);
  sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]);
  sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]);

  sCh9->SetVertex(0,-xomega[17], yomega[17]);
  sCh9->SetVertex(1,-xomega[16], yomega[16]);
  sCh9->SetVertex(2,-xomega[19], yomega[19]);
  sCh9->SetVertex(3,-xomega[18], yomega[18]);

  sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]);
  sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]);
  sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]);
  sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]);

  sCh11->SetVertex(0,-xomega[13], yomega[13]);
  sCh11->SetVertex(1,-xomega[12], yomega[12]);
  sCh11->SetVertex(2,-xomega[15], yomega[15]);
  sCh11->SetVertex(3,-xomega[14], yomega[14]);

  // Bigger end: determine the coordinates of the points of carbon fiber

  // Drawings give only the radius, convert it to the apothegm
  Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
					  - 0.25*kInnerACone*kInnerACone);
  Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
					  - 0.25*kOuterACone*kOuterACone);

  CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
			kOuterACone,kOuterBCone,kOuterRadiusCone,
			kTheta,xshld,yshld);

  sC1->SetVertex(4, xshld[12], yshld[12]);
  sC1->SetVertex(5, xshld[11], yshld[11]);
  sC1->SetVertex(6, xshld[ 0], yshld[ 0]);
  sC1->SetVertex(7, xshld[23], yshld[23]);

  sC2->SetVertex(4, xshld[11], yshld[11]);
  sC2->SetVertex(5, xshld[10], yshld[10]);
  sC2->SetVertex(6, xshld[ 1], yshld[ 1]);
  sC2->SetVertex(7, xshld[ 0], yshld[ 0]);

  sC3->SetVertex(4, xshld[10], yshld[10]);
  sC3->SetVertex(5, xshld[ 9], yshld[ 9]);
  sC3->SetVertex(6, xshld[ 2], yshld[ 2]);
  sC3->SetVertex(7, xshld[ 1], yshld[ 1]);

  sC4->SetVertex(4, xshld[ 9], yshld[ 9]);
  sC4->SetVertex(5, xshld[ 8], yshld[ 8]);
  sC4->SetVertex(6, xshld[ 3], yshld[ 3]);
  sC4->SetVertex(7, xshld[ 2], yshld[ 2]);

  sC5->SetVertex(4, xshld[ 8], yshld[ 8]);
  sC5->SetVertex(5, xshld[ 7], yshld[ 7]);
  sC5->SetVertex(6, xshld[ 4], yshld[ 4]);
  sC5->SetVertex(7, xshld[ 3], yshld[ 3]);

  sC6->SetVertex(4, xshld[ 7], yshld[ 7]);
  sC6->SetVertex(5, xshld[ 6], yshld[ 6]);
  sC6->SetVertex(6, xshld[ 5], yshld[ 5]);
  sC6->SetVertex(7, xshld[ 4], yshld[ 4]);

  sC7->SetVertex(4,-xshld[10], yshld[10]);
  sC7->SetVertex(5,-xshld[11], yshld[11]);
  sC7->SetVertex(6,-xshld[ 0], yshld[ 0]);
  sC7->SetVertex(7,-xshld[ 1], yshld[ 1]);

  sC8->SetVertex(4,-xshld[ 9], yshld[ 9]);
  sC8->SetVertex(5,-xshld[10], yshld[10]);
  sC8->SetVertex(6,-xshld[ 1], yshld[ 1]);
  sC8->SetVertex(7,-xshld[ 2], yshld[ 2]);

  sC9->SetVertex(4,-xshld[ 8], yshld[ 8]);
  sC9->SetVertex(5,-xshld[ 9], yshld[ 9]);
  sC9->SetVertex(6,-xshld[ 2], yshld[ 2]);
  sC9->SetVertex(7,-xshld[ 3], yshld[ 3]);

  sC10->SetVertex(4,-xshld[ 7], yshld[ 7]);
  sC10->SetVertex(5,-xshld[ 8], yshld[ 8]);
  sC10->SetVertex(6,-xshld[ 3], yshld[ 3]);
  sC10->SetVertex(7,-xshld[ 4], yshld[ 4]);

  sC11->SetVertex(4,-xshld[ 6], yshld[ 6]);
  sC11->SetVertex(5,-xshld[ 7], yshld[ 7]);
  sC11->SetVertex(6,-xshld[ 4], yshld[ 4]);
  sC11->SetVertex(7,-xshld[ 5], yshld[ 5]);

  // Then rescale to get the air volume dimensions
    InsidePoint(xshld[23], yshld[23],
		xshld[ 0], yshld[ 0],
		xshld[ 1], yshld[ 1], kThicknessCone,
		xair[0], yair[0]);
  for (Int_t i=1; i<23; i++) {
    InsidePoint(xshld[i-1], yshld[i-1],
		xshld[ i ], yshld[ i ],
		xshld[i+1], yshld[i+1], kThicknessCone,
		xair[i], yair[i]);
  }
    InsidePoint(xshld[22], yshld[22],
		xshld[23], yshld[23],
		xshld[ 0], yshld[ 0], kThicknessCone,
		xair[23], yair[23]);

  // Then use them to determine the Omega shape points
  CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);

  // Finally fill the big end coordinates of the air shapes
  sCh1->SetVertex(4, xomega[ 0], yomega[ 0]);
  sCh1->SetVertex(5, xomega[ 1], yomega[ 1]);
  sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]);
  sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]);

  sCh2->SetVertex(4, xomega[20], yomega[20]);
  sCh2->SetVertex(5, xomega[21], yomega[21]);
  sCh2->SetVertex(6, xomega[22], yomega[22]);
  sCh2->SetVertex(7, xomega[23], yomega[23]);

  sCh3->SetVertex(4, xomega[ 2], yomega[ 2]);
  sCh3->SetVertex(5, xomega[ 3], yomega[ 3]);
  sCh3->SetVertex(6, xomega[ 4], yomega[ 4]);
  sCh3->SetVertex(7, xomega[ 5], yomega[ 5]);

  sCh4->SetVertex(4, xomega[16], yomega[16]);
  sCh4->SetVertex(5, xomega[17], yomega[17]);
  sCh4->SetVertex(6, xomega[18], yomega[18]);
  sCh4->SetVertex(7, xomega[19], yomega[19]);

  sCh5->SetVertex(4, xomega[ 6], yomega[ 6]);
  sCh5->SetVertex(5, xomega[ 7], yomega[ 7]);
  sCh5->SetVertex(6, xomega[ 8], yomega[ 8]);
  sCh5->SetVertex(7, xomega[ 9], yomega[ 9]);

  sCh6->SetVertex(4, xomega[12], yomega[12]);
  sCh6->SetVertex(5, xomega[13], yomega[13]);
  sCh6->SetVertex(6, xomega[14], yomega[14]);
  sCh6->SetVertex(7, xomega[15], yomega[15]);

  sCh7->SetVertex(4,-xomega[21], yomega[21]);
  sCh7->SetVertex(5,-xomega[20], yomega[20]);
  sCh7->SetVertex(6,-xomega[23], yomega[23]);
  sCh7->SetVertex(7,-xomega[22], yomega[22]);

  sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]);
  sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]);
  sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]);
  sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]);

  sCh9->SetVertex(4,-xomega[17], yomega[17]);
  sCh9->SetVertex(5,-xomega[16], yomega[16]);
  sCh9->SetVertex(6,-xomega[19], yomega[19]);
  sCh9->SetVertex(7,-xomega[18], yomega[18]);

  sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]);
  sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]);
  sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]);
  sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]);

  sCh11->SetVertex(4,-xomega[13], yomega[13]);
  sCh11->SetVertex(5,-xomega[12], yomega[12]);
  sCh11->SetVertex(6,-xomega[15], yomega[15]);
  sCh11->SetVertex(7,-xomega[14], yomega[14]);

/*
  for(Int_t i=0; i<4; i++){
    InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0],
		sC1->GetVertices()[((i+3)%4)*2+1],
		sC1->GetVertices()[i*2+0],
		sC1->GetVertices()[i*2+1],
		sC1->GetVertices()[((i+1)%4)*2+0],
		sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
    sCh1->SetVertex(i,x,y);

    InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0],
		sC1->GetVertices()[((i+3)%4 +4)*2+1],
		sC1->GetVertices()[(i+4)*2+0],
		sC1->GetVertices()[(i+4)*2+1],
		sC1->GetVertices()[((i+1)%4 +4)*2+0],
		sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
    sCh1->SetVertex(i+4,x,y);

    InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0],
		sC2->GetVertices()[((i+3)%4)*2+1],
		sC2->GetVertices()[i*2+0],
		sC2->GetVertices()[i*2+1],
		sC2->GetVertices()[((i+1)%4)*2+0],
		sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
    sCh2->SetVertex(i,x,y);

    InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0],
		sC2->GetVertices()[((i+3)%4 +4)*2+1],
		sC2->GetVertices()[(i+4)*2+0],
		sC2->GetVertices()[(i+4)*2+1],
		sC2->GetVertices()[((i+1)%4 +4)*2+0],
		sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
    sCh2->SetVertex(i+4,x,y);
  }
*/
  // Finally the carbon fiber Ring with its Wings and their
  // stesalite inserts. They are Tube and TubeSeg shapes

  TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing,
				     kHalfLengthRing);

  TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing,
					   kOuterRadiusRing-kThicknessRing,
					   kHalfLengthRing-kThicknessRing);

  Double_t angleWideWing, angleWideWingThickness;
  angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg();
  angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg();

  TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing,
					   kHalfLengthRing, 0, angleWideWing);

  TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing,
             kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing,
             angleWideWingThickness, angleWideWing-angleWideWingThickness);


  // We have the shapes: now create the real volumes

  TGeoMedium *medSPDcf  = mgr->GetMedium("ITS_SPD shield$");
  TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$");
  TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite

  TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield",
					     centralshape,medSPDcf);
  centralshield->SetVisibility(kTRUE);
  centralshield->SetLineColor(7);
  centralshield->SetLineWidth(1);
  centralshield->SetFillColor(centralshield->GetLineColor());
  centralshield->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair1 = new TGeoVolume("SPDcentralair1shield",
					   centralair1shape,medSPDair);
  centralair1->SetVisibility(kTRUE);
  centralair1->SetLineColor(5); // Yellow
  centralair1->SetLineWidth(1);
  centralair1->SetFillColor(centralair1->GetLineColor());
  centralair1->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair2 = new TGeoVolume("SPDcentralair2shield",
					   centralair2shape,medSPDair);
  centralair2->SetVisibility(kTRUE);
  centralair2->SetLineColor(5); // Yellow
  centralair2->SetLineWidth(1);
  centralair2->SetFillColor(centralair2->GetLineColor());
  centralair2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair3 = new TGeoVolume("SPDcentralair3shield",
					   centralair3shape,medSPDair);
  centralair3->SetVisibility(kTRUE);
  centralair3->SetLineColor(5); // Yellow
  centralair3->SetLineWidth(1);
  centralair3->SetFillColor(centralair3->GetLineColor());
  centralair3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair4 = new TGeoVolume("SPDcentralair4shield",
					   centralair4shape,medSPDair);
  centralair4->SetVisibility(kTRUE);
  centralair4->SetLineColor(5); // Yellow
  centralair4->SetLineWidth(1);
  centralair4->SetFillColor(centralair4->GetLineColor());
  centralair4->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair5 = new TGeoVolume("SPDcentralair5shield",
					   centralair5shape,medSPDair);
  centralair5->SetVisibility(kTRUE);
  centralair5->SetLineColor(5); // Yellow
  centralair5->SetLineWidth(1);
  centralair5->SetFillColor(centralair5->GetLineColor());
  centralair5->SetFillStyle(4090); // 90% transparent

  TGeoVolume *centralair6 = new TGeoVolume("SPDcentralair6shield",
					   centralair6shape,medSPDair);
  centralair6->SetVisibility(kTRUE);
  centralair6->SetLineColor(5); // Yellow
  centralair6->SetLineWidth(1);
  centralair6->SetFillColor(centralair6->GetLineColor());
  centralair6->SetFillStyle(4090); // 90% transparent

  centralshield->AddNode(centralair1,1,0);
  centralshield->AddNode(centralair2,1,0);
  centralshield->AddNode(centralair2,2,new TGeoRotation("",90,180,-90));
  centralshield->AddNode(centralair3,1,0);
  centralshield->AddNode(centralair3,2,new TGeoRotation("",90,180,-90));
  centralshield->AddNode(centralair4,1,0);
  centralshield->AddNode(centralair4,2,new TGeoRotation("",90,180,-90));
  centralshield->AddNode(centralair5,1,0);
  centralshield->AddNode(centralair5,2,new TGeoRotation("",90,180,-90));
  centralshield->AddNode(centralair6,1,0);
  centralshield->AddNode(centralair6,2,new TGeoRotation("",90,180,-90));

  TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
					     endcapshape,medSPDcf);
  endcapshield->SetVisibility(kTRUE);
  endcapshield->SetLineColor(7);
  endcapshield->SetLineWidth(1);

  TGeoVolume *endcapair1 = new TGeoVolume("SPDendcapair1shield",
					  endcapair1shape,medSPDair);
  endcapair1->SetVisibility(kTRUE);
  endcapair1->SetLineColor(5); // Yellow
  endcapair1->SetLineWidth(1);
  endcapair1->SetFillColor(endcapair1->GetLineColor());
  endcapair1->SetFillStyle(4090); // 90% transparent

  TGeoVolume *endcapair2 = new TGeoVolume("SPDendcapair2shield",
					  endcapair2shape,medSPDair);
  endcapair2->SetVisibility(kTRUE);
  endcapair2->SetLineColor(5); // Yellow
  endcapair2->SetLineWidth(1);
  endcapair2->SetFillColor(endcapair2->GetLineColor());
  endcapair2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *endcapair3 = new TGeoVolume("SPDendcapair3shield",
					  endcapair3shape,medSPDair);
  endcapair3->SetVisibility(kTRUE);
  endcapair3->SetLineColor(5); // Yellow
  endcapair3->SetLineWidth(1);
  endcapair3->SetFillColor(endcapair3->GetLineColor());
  endcapair3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *endcapair4 = new TGeoVolume("SPDendcapair4shield",
					  endcapair4shape,medSPDair);
  endcapair4->SetVisibility(kTRUE);
  endcapair4->SetLineColor(5); // Yellow
  endcapair4->SetLineWidth(1);
  endcapair4->SetFillColor(endcapair4->GetLineColor());
  endcapair4->SetFillStyle(4090); // 90% transparent

  TGeoVolume *endcapair5 = new TGeoVolume("SPDendcapair5shield",
					  endcapair5shape,medSPDair);
  endcapair5->SetVisibility(kTRUE);
  endcapair5->SetLineColor(5); // Yellow
  endcapair5->SetLineWidth(1);
  endcapair5->SetFillColor(endcapair5->GetLineColor());
  endcapair5->SetFillStyle(4090); // 90% transparent

  TGeoVolume *endcapair6 = new TGeoVolume("SPDendcapair6shield",
					  endcapair6shape,medSPDair);
  endcapair6->SetVisibility(kTRUE);
  endcapair6->SetLineColor(5); // Yellow
  endcapair6->SetLineWidth(1);
  endcapair6->SetFillColor(endcapair6->GetLineColor());
  endcapair6->SetFillStyle(4090); // 90% transparent

  endcapshield->AddNode(endcapair1,1,0);
  endcapshield->AddNode(endcapair2,1,0);
  endcapshield->AddNode(endcapair2,2,new TGeoRotation("",90,180,-90));
  endcapshield->AddNode(endcapair3,1,0);
  endcapshield->AddNode(endcapair3,2,new TGeoRotation("",90,180,-90));
  endcapshield->AddNode(endcapair4,1,0);
  endcapshield->AddNode(endcapair4,2,new TGeoRotation("",90,180,-90));
  endcapshield->AddNode(endcapair5,1,0);
  endcapshield->AddNode(endcapair5,2,new TGeoRotation("",90,180,-90));
  endcapshield->AddNode(endcapair6,1,0);
  endcapshield->AddNode(endcapair6,2,new TGeoRotation("",90,180,-90));

  TGeoVolume *vC1 = new TGeoVolume("SPDconeshieldV1",sC1,medSPDcf);
  vC1->SetVisibility(kTRUE);
  vC1->SetLineColor(7);
  vC1->SetLineWidth(1);
  vC1->SetFillColor(vC1->GetLineColor());
  vC1->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
  vCh1->SetVisibility(kTRUE);
  vCh1->SetLineColor(5); // Yellow
  vCh1->SetLineWidth(1);
  vCh1->SetFillColor(vCh1->GetLineColor());
  vCh1->SetFillStyle(4090); // 90% transparent

  vC1->AddNode(vCh1,1,0);

  TGeoVolume *vC2 = new TGeoVolume("SPDconeshieldV2",sC2,medSPDcf);
  vC2->SetVisibility(kTRUE);
  vC2->SetLineColor(7);
  vC2->SetLineWidth(1);
  vC2->SetFillColor(vC2->GetLineColor());
  vC2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
  vCh2->SetVisibility(kTRUE);
  vCh2->SetLineColor(5); // Yellow
  vCh2->SetLineWidth(1);
  vCh2->SetFillColor(vCh2->GetLineColor());
  vCh2->SetFillStyle(4090); // 90% transparent

  vC2->AddNode(vCh2,1,0);

  TGeoVolume *vC3 = new TGeoVolume("SPDconeshieldV3",sC3,medSPDcf);
  vC3->SetVisibility(kTRUE);
  vC3->SetLineColor(7);
  vC3->SetLineWidth(1);
  vC3->SetFillColor(vC3->GetLineColor());
  vC3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh3 = new TGeoVolume("SPDconeshieldH3",sCh3,medSPDair);
  vCh3->SetVisibility(kTRUE);
  vCh3->SetLineColor(5); // Yellow
  vCh3->SetLineWidth(1);
  vCh3->SetFillColor(vCh3->GetLineColor());
  vCh3->SetFillStyle(4090); // 90% transparent

  vC3->AddNode(vCh3,1,0);

  TGeoVolume *vC4 = new TGeoVolume("SPDconeshieldV4",sC4,medSPDcf);
  vC4->SetVisibility(kTRUE);
  vC4->SetLineColor(7);
  vC4->SetLineWidth(1);
  vC4->SetFillColor(vC4->GetLineColor());
  vC4->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh4 = new TGeoVolume("SPDconeshieldH4",sCh4,medSPDair);
  vCh4->SetVisibility(kTRUE);
  vCh4->SetLineColor(5); // Yellow
  vCh4->SetLineWidth(1);
  vCh4->SetFillColor(vCh4->GetLineColor());
  vCh4->SetFillStyle(4090); // 90% transparent

  vC4->AddNode(vCh4,1,0);

  TGeoVolume *vC5 = new TGeoVolume("SPDconeshieldV5",sC5,medSPDcf);
  vC5->SetVisibility(kTRUE);
  vC5->SetLineColor(7);
  vC5->SetLineWidth(1);
  vC5->SetFillColor(vC5->GetLineColor());
  vC5->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh5 = new TGeoVolume("SPDconeshieldH5",sCh5,medSPDair);
  vCh5->SetVisibility(kTRUE);
  vCh5->SetLineColor(5); // Yellow
  vCh5->SetLineWidth(1);
  vCh5->SetFillColor(vCh5->GetLineColor());
  vCh5->SetFillStyle(4090); // 90% transparent

  vC5->AddNode(vCh5,1,0);

  TGeoVolume *vC6 = new TGeoVolume("SPDconeshieldV6",sC6,medSPDcf);
  vC6->SetVisibility(kTRUE);
  vC6->SetLineColor(7);
  vC6->SetLineWidth(1);
  vC6->SetFillColor(vC6->GetLineColor());
  vC6->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh6 = new TGeoVolume("SPDconeshieldH6",sCh6,medSPDair);
  vCh6->SetVisibility(kTRUE);
  vCh6->SetLineColor(5); // Yellow
  vCh6->SetLineWidth(1);
  vCh6->SetFillColor(vCh6->GetLineColor());
  vCh6->SetFillStyle(4090); // 90% transparent

  vC6->AddNode(vCh6,1,0);

  TGeoVolume *vC7 = new TGeoVolume("SPDconeshieldV7",sC7,medSPDcf);
  vC7->SetVisibility(kTRUE);
  vC7->SetLineColor(7);
  vC7->SetLineWidth(1);
  vC7->SetFillColor(vC7->GetLineColor());
  vC7->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh7 = new TGeoVolume("SPDconeshieldH7",sCh7,medSPDair);
  vCh7->SetVisibility(kTRUE);
  vCh7->SetLineColor(5); // Yellow
  vCh7->SetLineWidth(1);
  vCh7->SetFillColor(vCh7->GetLineColor());
  vCh7->SetFillStyle(4090); // 90% transparent

  vC7->AddNode(vCh7,1,0);

  TGeoVolume *vC8 = new TGeoVolume("SPDconeshieldV8",sC8,medSPDcf);
  vC8->SetVisibility(kTRUE);
  vC8->SetLineColor(7);
  vC8->SetLineWidth(1);
  vC8->SetFillColor(vC8->GetLineColor());
  vC8->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh8 = new TGeoVolume("SPDconeshieldH8",sCh8,medSPDair);
  vCh8->SetVisibility(kTRUE);
  vCh8->SetLineColor(5); // Yellow
  vCh8->SetLineWidth(1);
  vCh8->SetFillColor(vCh8->GetLineColor());
  vCh8->SetFillStyle(4090); // 90% transparent

  vC8->AddNode(vCh8,1,0);

  TGeoVolume *vC9 = new TGeoVolume("SPDconeshieldV9",sC9,medSPDcf);
  vC9->SetVisibility(kTRUE);
  vC9->SetLineColor(7);
  vC9->SetLineWidth(1);
  vC9->SetFillColor(vC9->GetLineColor());
  vC9->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh9 = new TGeoVolume("SPDconeshieldH9",sCh9,medSPDair);
  vCh9->SetVisibility(kTRUE);
  vCh9->SetLineColor(5); // Yellow
  vCh9->SetLineWidth(1);
  vCh9->SetFillColor(vCh9->GetLineColor());
  vCh9->SetFillStyle(4090); // 90% transparent

  vC9->AddNode(vCh9,1,0);

  TGeoVolume *vC10 = new TGeoVolume("SPDconeshieldV10",sC10,medSPDcf);
  vC10->SetVisibility(kTRUE);
  vC10->SetLineColor(7);
  vC10->SetLineWidth(1);
  vC10->SetFillColor(vC10->GetLineColor());
  vC10->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh10 = new TGeoVolume("SPDconeshieldH10",sCh10,medSPDair);
  vCh10->SetVisibility(kTRUE);
  vCh10->SetLineColor(5); // Yellow
  vCh10->SetLineWidth(1);
  vCh10->SetFillColor(vCh10->GetLineColor());
  vCh10->SetFillStyle(4090); // 90% transparent

  vC10->AddNode(vCh10,1,0);

  TGeoVolume *vC11 = new TGeoVolume("SPDconeshieldV11",sC11,medSPDcf);
  vC11->SetVisibility(kTRUE);
  vC11->SetLineColor(7);
  vC11->SetLineWidth(1);
  vC11->SetFillColor(vC11->GetLineColor());
  vC11->SetFillStyle(4090); // 90% transparent

  TGeoVolume *vCh11 = new TGeoVolume("SPDconeshieldH11",sCh11,medSPDair);
  vCh11->SetVisibility(kTRUE);
  vCh11->SetLineColor(5); // Yellow
  vCh11->SetLineWidth(1);
  vCh11->SetFillColor(vCh11->GetLineColor());
  vCh11->SetFillStyle(4090); // 90% transparent

  vC11->AddNode(vCh11,1,0);

  TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
  ring->SetVisibility(kTRUE);
  ring->SetLineColor(7);
  ring->SetLineWidth(1);

  TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert",
					  ringinsertshape,medSPDste);
  ringinsert->SetVisibility(kTRUE);
  ringinsert->SetLineColor(3); // Green
//  ringinsert->SetLineWidth(1);
  ringinsert->SetFillColor(ringinsert->GetLineColor());
  ringinsert->SetFillStyle(4010); // 10% transparent

  ring->AddNode(ringinsert,1,0);

  TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf);
  wing->SetVisibility(kTRUE);
  wing->SetLineColor(7);
  wing->SetLineWidth(1);

  TGeoVolume *winginsert = new TGeoVolume("SPDshieldringinsert",
					  winginsertshape,medSPDste);
  winginsert->SetVisibility(kTRUE);
  winginsert->SetLineColor(3); // Green
//  winginsert->SetLineWidth(1);
  winginsert->SetFillColor(winginsert->GetLineColor());
  winginsert->SetFillStyle(4010); // 10% transparent

  wing->AddNode(winginsert,1,0);


  // Add all volumes in the assembly
  const Double_t kLittleZTrans = 0.1*fgkmm;
  vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans));
  vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans,
				  new TGeoRotation("",180,0,0)));

  zpos = kHalfLengthCentral+kHalfLengthEndCap;
  vM->AddNode(endcapshield,1,
	      new TGeoTranslation(0,0, zpos-kLittleZTrans));
  vM->AddNode(endcapshield,2,
	      new TGeoTranslation(0,0,-zpos-kLittleZTrans));
  vM->AddNode(endcapshield,3,new TGeoCombiTrans(
              0, 0, zpos-kLittleZTrans, new TGeoRotation("",180,0,0) ) );
  vM->AddNode(endcapshield,4,new TGeoCombiTrans(
              0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,0,0) ) );

  zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone;
  vM->AddNode(vC1 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC2 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC3 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC4 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC5 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC6 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC7 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC8 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC9 ,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC10,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));
  vM->AddNode(vC11,1, new TGeoTranslation(0, 0,  zpos-kLittleZTrans));

  vM->AddNode(vC1 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC2 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC3 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC4 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC5 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC6 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC7 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC8 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC9 ,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC10,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));
  vM->AddNode(vC11,2, new TGeoCombiTrans(0, 0,  zpos-kLittleZTrans,
				new TGeoRotation("", 0, 0, 180)   ));

  vM->AddNode(vC1 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC2 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC3 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC4 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC5 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC6 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC7 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC8 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC9 ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC10,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));
  vM->AddNode(vC11,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 0)   ));

  vM->AddNode(vC1 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC2 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC3 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC4 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC5 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC6 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC7 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC8 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC9 ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC10,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));
  vM->AddNode(vC11,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
				new TGeoRotation("", 0, 180, 180)   ));

  zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
       + kHalfLengthRing;
  vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
  vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));

  for (Int_t i=0; i<4; i++) {
    Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
    vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
			       new TGeoRotation("",thetaW,0,0) ) );
    vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
			       new TGeoRotation("",thetaW,0,0) ) );
  }

  // Some debugging if requested
  if(GetDebug(1)){
    vM->PrintNodes();
    vM->InspectShape();
  }

  // Finally put the entire shield in the mother volume
  moth->AddNode(vM,1,0);

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSPDThermalShape(
     Double_t ina, Double_t inb, Double_t inr,
     Double_t oua, Double_t oub, Double_t our,
     Double_t   t, Double_t *x , Double_t *y ) const
{
//
// Creates the proper sequence of X and Y coordinates to determine
// the base XTru polygon for the SPD thermal shapes
//
// Input:
//        ina, inb : inner shape sides
//        inr      : inner radius
//        oua, oub : outer shape sides
//        our      : outer radius
//        t        : theta angle
//
// Output:
//        x, y : coordinate vectors [24]
//
// Created:      14 Nov 2007  Mario Sitta
// Updated:      11 Dec 2007  Mario Sitta
//
  Double_t xlocal[6],ylocal[6];

  //Create the first inner quadrant (X > 0)
  FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
  for (Int_t i=0; i<6; i++) {
    x[i] = xlocal[i];
    y[i] = ylocal[i];
  }

  // Then reflex on the second quadrant (X < 0)
  for (Int_t i=0; i<6; i++) {
    x[23-i] = -x[i];
    y[23-i] =  y[i];
  }

  // Now create the first outer quadrant (X > 0)
  FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
  for (Int_t i=0; i<6; i++) {
    x[11-i] = xlocal[i];
    y[11-i] = ylocal[i];
  }

  // Finally reflex on the second quadrant (X < 0)
  for (Int_t i=0; i<6; i++) {
    x[12+i] = -x[11-i];
    y[12+i] =  y[11-i];
  }

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSPDOmegaShape(
                   const Double_t *xin, const Double_t *yin, Double_t  d,
		   Double_t   *x, Double_t *y)
{
//
// Creates the proper sequence of X and Y coordinates to determine
// the SPD Omega XTru polygon
//
// Input:
//        xin, yin : coordinates of the air volume
//        d        : Omega shape thickness
//        t        : theta angle
//
// Output:
//        x, y     : coordinate vectors [48]
//
// Created:      17 Nov 2007  Mario Sitta
// Updated:      11 Dec 2007  Mario Sitta
// Updated:      20 Feb 2009  Mario Sitta       New algorithm (the old one
//                                              gives erroneous vertexes)
//

  // This vector contains the index of those points which coincide
  // with the corresponding points in the air shape
  Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};

  // First fill those vertexes corresponding to
  // the edges aligned to the air shape edges
  for (Int_t j=0; j<12; j++) {
    x[*(indexAir2Omega+j)] = xin[j];
    y[*(indexAir2Omega+j)] = yin[j];
  }

  // Now get the coordinates of the first inner point
  PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);

  // Knowing this, the second internal point can be determined
  InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);

  // The third point is now computable
  ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);

  // Repeat this logic
  InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);

  ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);

  InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);

  ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);

  InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);

  ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);

  InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);

  // These need to be fixed explicitly
  x[12] = x[11];
  y[12] = y[11] + d;
  x[13] = x[10] + d;
  y[13] = y[12];

  // Finally reflect on the negative side
  for (Int_t i=0; i<24; i++) {
    x[24+i] = -x[23-i];
    y[24+i] =  y[23-i];
  }

  // Wow ! We've finished
  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
						Double_t r, Double_t t,
						Double_t *x, Double_t *y) const
{
//
// Creates the partial sequence of X and Y coordinates to determine
// the lateral part of the SPD thermal shield
//
// Input:
//        a, b : shape sides
//        r    : radius
//        t    : theta angle
//
// Output:
//        x, y : coordinate vectors [6]
//
// Created:      14 Nov 2007  Mario Sitta
//
  x[0] = a/2;
  y[0] = r;

  x[1] = x[0] + b * TMath::Cos(t/2);
  y[1] = y[0] - b * TMath::Sin(t/2);

  x[2] = x[1] + a * TMath::Cos(t);
  y[2] = y[1] - a * TMath::Sin(t);

  x[3] = x[2] + b * TMath::Cos(3*t/2);
  y[3] = y[2] - b * TMath::Sin(3*t/2);

  x[4] = x[3] + a * TMath::Cos(2*t);
  y[4] = y[3] - a * TMath::Sin(2*t);

  x[5] = x[4];
  y[5] = 0.;

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
			      Double_t x2, Double_t y2, Double_t d,
			      Double_t &x, Double_t &y) const
{
//
// Determines the X and Y of the first internal point of the Omega shape
// (i.e. the coordinates of a point given two parallel lines passing by
// two points and placed at a known distance)
//
// Input:
//        x1, y1 : first point
//        x2, y2 : second point
//        d      : distance between the two lines
//
// Output:
//        x, y   : coordinate of the point
//
// Created:      22 Feb 2009  Mario Sitta
//
//Begin_Html
/*
<img src="ITS/doc/PointFromParallelLines.gif">
*/
//End_Html

  // The slope of the paralles lines at a distance d
  Double_t m; 

  // The parameters of the solving equation
  // a x^2 - 2 b x + c = 0
  Double_t a = (x1 - x2)*(x1 - x2) - d*d;
  Double_t b = (x1 - x2)*(y1 - y2);
  Double_t c = (y1 - y2)*(y1 - y2) - d*d;

  // (delta4 is Delta/4 because we use the reduced formula)
  Double_t delta4 = b*b - a*c;

  // Compute the slope of the two parallel lines
  // (one of the two possible slopes, the one with the smaller
  // absolute value is needed)
  if (delta4 < 0) { // Should never happen with our data, but just to be sure
    x = -1;         // x is expected positive, so this flags an error
    return;
  } else
    m = (b + TMath::Sqrt(delta4))/a;  // b is negative with our data

  // Finally compute the coordinates of the point
  x = x2 + (y1 - y2 - d)/m;
  y = y1 - d;

  // Done
  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
					    Double_t x2, Double_t y2,
					    Double_t x3, Double_t y3,
					    Double_t &x, Double_t &y) const
{
//
// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
// lying on the line parallel to the line passing by these points,
// at a distance d and passing by the point (x3,y3), which is symmetric to
// the third point with respect to the axis of the segment delimited by
// the two first points.
//
// Input:
//        x1, y1 : first point
//        x2, y2 : second point
//        x3, y3 : third point
//        d      : distance between the two lines
//
// Output:
//        x, y   : coordinate of the reflected point
//
// Created:      22 Feb 2009  Mario Sitta
//
//Begin_Html
/*
<img src="ITS/doc/ReflectPoint.gif">
*/
//End_Html

  // The slope of the line passing by the first two points
  Double_t k = (y2 - y1)/(x2 - x1);

  // The middle point of the segment 1-2
  Double_t xK = (x1 + x2)/2.;
  Double_t yK = (y1 + y2)/2.;

  // The intercept between the axis of the segment 1-2 and the line
  // passing by 3 and parallel to the line passing by 1-2
  Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
  Double_t yH = k*(xH - x3) + y3;

  // The point symmetric to 3 with respect to H
  x = 2*xH - x3;
  y = 2*yH - y3;

  // Done
  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SDD support cone and cylinder geometry as a
// volume assembly and adds it to the mother volume
// (part of this code is taken or anyway inspired to SDDCone method
// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      18 Feb 2008  Mario Sitta
// Updated:      25 Jul 2008  Mario Sitta   SDDCarbonFiberCone simpler
// Updated:      10 Jun 2010  Mario Sitta   Cables across cone holes added
//
// Technical data are taken from:  "Supporto Generale Settore SDD"
// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
// (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D), 
// private communication with B. Giraudo

  // Dimensions of the Central cylinder and flanges
  const Double_t kCylinderHalfLength = (790.0/2)*fgkmm;
  const Double_t kCylinderInnerR     = (210.0/2)*fgkmm;
  const Double_t kCylinderOuterR     = (231.0/2)*fgkmm;
  const Double_t kFlangeHalfLength   = ( 15.0/2)*fgkmm;
  const Double_t kFlangeInnerR       = (210.5/2)*fgkmm;
  const Double_t kFlangeOuterR       = (230.5/2)*fgkmm;
  const Double_t kInsertoHalfLength  =
                                     kCylinderHalfLength - 2*kFlangeHalfLength;
//  const Double_t kCFThickness        = kFlangeInnerR - kCylinderInnerR;
  const Double_t kBoltDiameter       =       6.0*fgkmm; // M6 screw
  const Double_t kBoltDepth          =       6.0*fgkmm; // In the flange
  const Double_t kBoltRadius         = (220.0/2)*fgkmm; // Radius in flange
  const Double_t kThetaBolt          =      30.0*fgkDegree;
  const Int_t    kNBolts             = (Int_t)(360.0/kThetaBolt);
  // Dimensions of the Cone
  const Double_t kConeROutMin        = (540.0/2)*fgkmm;
  const Double_t kConeROutMax        = (560.0/2)*fgkmm;
  const Double_t kConeRCurv          =      10.0*fgkmm; // Radius of curvature
  const Double_t kConeRinMin         = (210.0/2)*fgkmm;
//  const Double_t kConeRinMax         = (216.0/2)*fgkmm;
  const Double_t kConeRinCylinder    = (231.0/2)*fgkmm;
  const Double_t kConeZCylinder      =     192.0*fgkmm;
  const Double_t kConeZOuterMilled   =      23.0*fgkmm;
  const Double_t kConeDZin           =      15.0*fgkmm; // ???
  const Double_t kConeThickness      =      10.0*fgkmm; // Rohacell + Carb.Fib.
  const Double_t kConeTheta          =      45.0*fgkDegree; // SDD cone angle
  const Double_t kSinConeTheta       =
                                     TMath::Sin(kConeTheta*TMath::DegToRad());
  const Double_t kCosConeTheta       =
                                     TMath::Cos(kConeTheta*TMath::DegToRad());
  const Double_t kTanConeTheta       =
                                     TMath::Tan(kConeTheta*TMath::DegToRad());
  // Dimensions of the Cone Inserts
  const Double_t kConeCFThickness    =       1.5*fgkmm;//Carbon fiber thickness
  // Dimensions of the Cone Holes
  const Double_t kHole1RMin          = (450.0/2)*fgkmm;
  const Double_t kHole1RMax          = (530.0/2)*fgkmm;
  const Double_t kHole2RMin          = (280.0/2)*fgkmm;
  const Double_t kHole2RMax          = (375.0/2)*fgkmm;
  const Double_t kHole1Phi           =      25.0*fgkDegree;
  const Double_t kHole2Phi           =      50.0*fgkDegree;
  const Double_t kHole3RMin          =     205.0*fgkmm;
  const Double_t kHole3DeltaR        =        15*fgkmm;
  const Double_t kHole3Width         =        30*fgkmm;
  const Int_t    kNHole3             =         6      ;
  const Double_t kHole4RMin          =     116.0*fgkmm;
  const Double_t kHole4DeltaR        =        15*fgkmm;
  const Double_t kHole4Width         =        30*fgkmm;
  //  const Int_t    kNHole4             =         3      ;
  // Fraction of materials in holes
  const Double_t kHolePlasticFrac    =       0.55846;
  const Double_t kHoleCuFrac         =       0.06319;
  const Double_t kHoleGlassFrac      =       0.02652;

  // Local variables
  Double_t x, y, z, t, dza, rmin, rmax;


  // Recover the needed materials
  TGeoMedium *medSDDcf    = mgr->GetMedium("ITS_SDD C (M55J)$");
  TGeoMedium *medSDDair   = mgr->GetMedium("ITS_SDD AIR$");
  TGeoMedium *medSDDste   = mgr->GetMedium("ITS_G10FR4$"); // stesalite
  TGeoMedium *medSDDroh   = mgr->GetMedium("ITS_ROHACELL$");
  TGeoMedium *medSDDss    = mgr->GetMedium("ITS_INOX$");
  TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
  TGeoMedium *medSDDCu    = mgr->GetMedium("ITS_COPPER$");
  TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");

  // First define the geometrical shapes

  // Central cylinder with its internal foam and the lateral flanges:
  // a carbon fiber Tube which contains a rohacell Tube and two
  // stesalite Tube's
  TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR,
					 kCylinderHalfLength);

  TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
					kInsertoHalfLength);

  TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
				       kFlangeHalfLength);

  // The flange bolt: it is a Tube
  TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth);

  // Debug if requested
  if (GetDebug(1)) {
    cylindershape->InspectShape();
    insertoshape->InspectShape();
    flangeshape->InspectShape();
    boltshape->InspectShape();
  }


  // We have the shapes: now create the real volumes

  TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder",
					  cylindershape,medSDDcf);
  cfcylinder->SetVisibility(kTRUE);
  cfcylinder->SetLineColor(4); // Blue
  cfcylinder->SetLineWidth(1);
  cfcylinder->SetFillColor(cfcylinder->GetLineColor());
  cfcylinder->SetFillStyle(4000); // 0% transparent

  TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder",
					    insertoshape,medSDDroh);
  foamcylinder->SetVisibility(kTRUE);
  foamcylinder->SetLineColor(3); // Green
  foamcylinder->SetLineWidth(1);
  foamcylinder->SetFillColor(foamcylinder->GetLineColor());
  foamcylinder->SetFillStyle(4050); // 50% transparent

  TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder",
					      flangeshape,medSDDste);
  flangecylinder->SetVisibility(kTRUE);
  flangecylinder->SetLineColor(2); // Red
  flangecylinder->SetLineWidth(1);
  flangecylinder->SetFillColor(flangecylinder->GetLineColor());
  flangecylinder->SetFillStyle(4050); // 50% transparent

  TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss);
  bolt->SetVisibility(kTRUE);
  bolt->SetLineColor(1);  // Black
  bolt->SetLineWidth(1);
  bolt->SetFillColor(bolt->GetLineColor());
  bolt->SetFillStyle(4050); // 50% transparent

  // Mount up the cylinder
  for(Int_t i=0; i<kNBolts; i++){
    t = kThetaBolt*i;
    x = kBoltRadius*CosD(t);
    y = kBoltRadius*SinD(t);
    z = kFlangeHalfLength-kBoltDepth;
    flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
  }

  cfcylinder->AddNode(foamcylinder,1,0);
  cfcylinder->AddNode(flangecylinder,1,
	      new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength));
  cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
              0, 0, -kInsertoHalfLength-kFlangeHalfLength,
	      new TGeoRotation("",0,180,0)     ) );


  // SDD Support Cone with its internal inserts: a carbon fiber Pcon
  // with holes which contains a stesalite Pcon which on turn contains a
  // rohacell Pcon

  dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;

  TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);

  coneshape->Z(0)     = 0.0;
  coneshape->Rmin(0)  = kConeROutMin;
  coneshape->Rmax(0)  = kConeROutMax;

  coneshape->Z(1)     = kConeZOuterMilled - dza;
  coneshape->Rmin(1)  = coneshape->GetRmin(0);
  coneshape->Rmax(1)  = coneshape->GetRmax(0);

  coneshape->Z(2)     = kConeZOuterMilled;
  coneshape->Rmax(2)  = coneshape->GetRmax(0);

  RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1),
		    coneshape->GetRmin(1),kConeTheta,z,rmin);
  coneshape->Z(3)     = z;
  coneshape->Rmin(3)  = rmin;

  coneshape->Rmin(2)  = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2));

  RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2),
		    coneshape->GetRmax(2),kConeTheta,z,rmax);
  coneshape->Z(4)     = z;
  coneshape->Rmax(4)  = rmax;
  coneshape->Rmin(4)  = RminFromZpCone(coneshape,3,kConeTheta,
				       coneshape->GetZ(4),0.0);

  coneshape->Rmax(3)  = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));

  coneshape->Z(6)     = kConeZCylinder - kConeDZin;

  RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
		    90.0-kConeTheta,z,rmin);
  coneshape->Z(5)     = z;
  coneshape->Rmin(5)  = RminFromZpCone(coneshape,3,kConeTheta,z);
  coneshape->Rmax(5)  = RmaxFromZpCone(coneshape,4,kConeTheta,z);

  RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
		    0.0,coneshape->Rmin(5),90.0,z,rmin);
  coneshape->Rmin(6)  = rmin;
  coneshape->Rmax(6)  = RmaxFromZpCone(coneshape,4,kConeTheta,
				       coneshape->GetZ(6));

  coneshape->Z(7)     = coneshape->GetZ(6);
  coneshape->Rmin(7)  = kConeRinMin;
  coneshape->Rmax(7)  = coneshape->GetRmax(6);

  coneshape->Rmin(8)  = kConeRinMin;

  RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
		    90.0-kConeTheta,z,rmax);
  coneshape->Z(8)     = z;
  coneshape->Rmax(8)  = rmax;

  coneshape->Z(9)     = kConeZCylinder;
  coneshape->Rmin(9)  = kConeRinMin;
  coneshape->Rmax(9)  = kConeRinCylinder;


  // SDD Cone Insert: another Pcon
  Double_t x0, y0, x1, y1, x2, y2;
  TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9);

  coneinsertshape->Z(0)    = coneshape->GetZ(0) + kConeCFThickness;
  coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness;
  coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness;

  x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
  x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
  x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
  coneinsertshape->Z(1)    = z;
  coneinsertshape->Rmin(1) = rmin;
  coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);

  x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1);
  x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2);
  x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
  coneinsertshape->Z(2)    = z;
  coneinsertshape->Rmax(2) = rmax;

  x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
  x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
  x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
  coneinsertshape->Z(3)    = z;
  coneinsertshape->Rmin(3) = rmin;

  x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1);
  x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3);
  coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1,
					  coneinsertshape->Z(2));

  x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
  x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
  x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
  coneinsertshape->Z(4)    = z;
  coneinsertshape->Rmax(4) = rmax;

  x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2);
  x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4);
  coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1,
					  coneinsertshape->Z(3));

  x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4);
  x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5);
  x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
  coneinsertshape->Z(5)    = z;
  coneinsertshape->Rmin(5) = rmin;
  coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) -
          kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4));

  x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3);
  x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5);
  coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1,
					  coneinsertshape->Z(4));

  x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5);
  x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6);
  x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kConeCFThickness, z, rmin);
  coneinsertshape->Z(6)    = z;
  coneinsertshape->Rmin(6) = rmin;
  coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) -
          kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4));

  coneinsertshape->Z(7)    = coneinsertshape->GetZ(6);
  coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness;
  coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6);

  coneinsertshape->Z(8)    = coneshape->GetZ(9) - kConeCFThickness;
  coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7);
  coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) -
          kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4));

  // SDD Cone Foam: another Pcon
  TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4);

  RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1),
		    coneinsertshape->GetRmin(1),kConeTheta,z,rmin);

  conefoamshape->Z(0)    = z;
  conefoamshape->Rmin(0) = rmin;
  conefoamshape->Rmax(0) = conefoamshape->GetRmin(0);

  conefoamshape->Z(1)    = conefoamshape->GetZ(0)+
                         (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta;
  conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta,
					  conefoamshape->GetZ(1));
  conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					  conefoamshape->GetZ(1));

  conefoamshape->Z(2)    = coneshape->GetZ(5)-kConeCFThickness;
  conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
					  conefoamshape->GetZ(2));
  conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					  conefoamshape->GetZ(2));

  conefoamshape->Z(3)    = coneinsertshape->GetZ(5)+
                         (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta;
  conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					  conefoamshape->GetZ(3));
  conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);

  // SDD Cone Holes: Pcon's
  // A single hole volume gives an overlap with coneinsert, so
  // three contiguous volumes are created: one to be put in the cone foam
  // and two in the cone carbon fiber envelope
  TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole1shape->Rmin(0) = kHole1RMax;
  hole1shape->Rmax(0) = hole1shape->GetRmin(0);
  hole1shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
				       hole1shape->GetRmin(0));

  hole1shape->Rmax(1) = hole1shape->GetRmax(0);
  hole1shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole1shape->GetRmax(1));
  hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
				       hole1shape->GetZ(1));

  hole1shape->Rmin(2) = kHole1RMin;
  hole1shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
				       hole1shape->GetRmin(2));
  hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
				       hole1shape->GetZ(2));

  hole1shape->Rmin(3) = hole1shape->GetRmin(2);
  hole1shape->Rmax(3) = hole1shape->GetRmin(3);
  hole1shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole1shape->GetRmax(3));

  TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole11shape->Rmin(0) = kHole1RMax;
  hole11shape->Rmax(0) = hole11shape->GetRmin(0);
  hole11shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole11shape->GetRmin(0));

  hole11shape->Rmax(1) = hole11shape->GetRmax(0);
  hole11shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole11shape->GetRmax(1));
  hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
					hole11shape->GetZ(1));

  hole11shape->Rmin(2) = kHole1RMin;
  hole11shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole11shape->GetRmin(2));
  hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
					hole11shape->GetZ(2));

  hole11shape->Rmin(3) = hole11shape->GetRmin(2);
  hole11shape->Rmax(3) = hole11shape->GetRmin(3);
  hole11shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole11shape->GetRmax(3));

  TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole12shape->Rmin(0) = kHole1RMax;
  hole12shape->Rmax(0) = hole12shape->GetRmin(0);
  hole12shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole12shape->GetRmin(0));

  hole12shape->Rmax(1) = hole12shape->GetRmax(0);
  hole12shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole12shape->GetRmax(1));
  hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					hole12shape->GetZ(1));

  hole12shape->Rmin(2) = kHole1RMin;
  hole12shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole12shape->GetRmin(2));
  hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
					hole12shape->GetZ(2));

  hole12shape->Rmin(3) = hole12shape->GetRmin(2);
  hole12shape->Rmax(3) = hole12shape->GetRmin(3);
  hole12shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole12shape->GetRmax(3));

  //
  TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole2shape->Rmin(0) = kHole2RMax;
  hole2shape->Rmax(0) = hole2shape->GetRmin(0);
  hole2shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
				       hole2shape->GetRmin(0));

  hole2shape->Rmax(1) = hole2shape->GetRmax(0);
  hole2shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole2shape->GetRmax(1));
  hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
				       hole2shape->GetZ(1));

  hole2shape->Rmin(2) = kHole2RMin;
  hole2shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
				       hole2shape->GetRmin(2));
  hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
				       hole2shape->GetZ(2));

  hole2shape->Rmin(3) = hole2shape->GetRmin(2);
  hole2shape->Rmax(3) = hole2shape->GetRmin(3);
  hole2shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole2shape->GetRmax(3));

  TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole21shape->Rmin(0) = kHole2RMax;
  hole21shape->Rmax(0) = hole21shape->GetRmin(0);
  hole21shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole21shape->GetRmin(0));

  hole21shape->Rmax(1) = hole21shape->GetRmax(0);
  hole21shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole21shape->GetRmax(1));
  hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
					hole21shape->GetZ(1));

  hole21shape->Rmin(2) = kHole2RMin;
  hole21shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole21shape->GetRmin(2));
  hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
					hole21shape->GetZ(2));

  hole21shape->Rmin(3) = hole21shape->GetRmin(2);
  hole21shape->Rmax(3) = hole21shape->GetRmin(3);
  hole21shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole21shape->GetRmax(3));

  TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole22shape->Rmin(0) = kHole2RMax;
  hole22shape->Rmax(0) = hole22shape->GetRmin(0);
  hole22shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole22shape->GetRmin(0));

  hole22shape->Rmax(1) = hole22shape->GetRmax(0);
  hole22shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole22shape->GetRmax(1));
  hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					hole22shape->GetZ(1));

  hole22shape->Rmin(2) = kHole2RMin;
  hole22shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole22shape->GetRmin(2));
  hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
					hole22shape->GetZ(2));

  hole22shape->Rmin(3) = hole22shape->GetRmin(2);
  hole22shape->Rmax(3) = hole22shape->GetRmin(3);
  hole22shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole22shape->GetRmax(3));

  //
  Double_t holePhi;
  holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();

  TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
  hole3shape->Rmax(0) = hole3shape->GetRmin(0);
  hole3shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
				       hole3shape->GetRmin(0));

  hole3shape->Rmax(1) = hole3shape->GetRmax(0);
  hole3shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole3shape->GetRmax(1));
  hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
				       hole3shape->GetZ(1));

  hole3shape->Rmin(2) = kHole3RMin;
  hole3shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
				       hole3shape->GetRmin(2));
  hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
				       hole3shape->GetZ(2));

  hole3shape->Rmin(3) = hole3shape->GetRmin(2);
  hole3shape->Rmax(3) = hole3shape->GetRmin(3);
  hole3shape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
				       hole3shape->GetRmax(3));

  TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
  hole31shape->Rmax(0) = hole31shape->GetRmin(0);
  hole31shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole31shape->GetRmin(0));

  hole31shape->Rmax(1) = hole31shape->GetRmax(0);
  hole31shape->Z(1)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole31shape->GetRmax(1));
  hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
					hole31shape->GetZ(1));

  hole31shape->Rmin(2) = kHole3RMin;
  hole31shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
					hole31shape->GetRmin(2));
  hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
					hole31shape->GetZ(2));

  hole31shape->Rmin(3) = hole31shape->GetRmin(2);
  hole31shape->Rmax(3) = hole31shape->GetRmin(3);
  hole31shape->Z(3)    = ZFromRminpCone(coneinsertshape,3,kConeTheta,
					hole31shape->GetRmax(3));

  TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
  hole32shape->Rmax(0) = hole32shape->GetRmin(0);
  hole32shape->Z(0)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole32shape->GetRmin(0));

  hole32shape->Rmax(1) = hole32shape->GetRmax(0);
  hole32shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole32shape->GetRmax(1));
  hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
					hole32shape->GetZ(1));

  hole32shape->Rmin(2) = kHole3RMin;
  hole32shape->Z(2)    = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
					hole32shape->GetRmin(2));
  hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
					hole32shape->GetZ(2));

  hole32shape->Rmin(3) = hole32shape->GetRmin(2);
  hole32shape->Rmax(3) = hole32shape->GetRmin(3);
  hole32shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
					hole32shape->GetRmax(3));

  //
  holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();

  TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR;
  hole4shape->Rmax(0) = hole4shape->GetRmin(0);
  hole4shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
				       hole4shape->GetRmin(0));

  hole4shape->Rmax(1) = hole4shape->GetRmax(0);
  hole4shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
				       hole4shape->GetRmax(1));
  hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
				       hole4shape->GetZ(1));

  hole4shape->Rmin(2) = kHole4RMin;
  hole4shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
				       hole4shape->GetRmin(2));
  hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
				       hole4shape->GetZ(2));

  hole4shape->Rmin(3) = hole4shape->GetRmin(2);
  hole4shape->Rmax(3) = hole4shape->GetRmin(3);
  hole4shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
				       hole4shape->GetRmax(3));

  // Cables to be put inside the holes: Pcon's
  // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
  TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
  hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
  hole1plastshape->Z(0)    = hole1shape->GetZ(0);

  hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
  hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
  hole1plastshape->Z(1)    = hole1shape->GetZ(1);

  dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;

  hole1plastshape->Rmin(2) = dza;
  hole1plastshape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					    hole1plastshape->GetRmin(2));
  hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
					    hole1plastshape->GetZ(2));

  hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
  hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
  hole1plastshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					    hole1plastshape->GetRmax(3));

  TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
  hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
  hole1Cushape->Z(0)    = hole1plastshape->GetZ(2);

  dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;

  hole1Cushape->Rmin(1) = dza;
  hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
  hole1Cushape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					 hole1Cushape->GetRmin(1));

  hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
  hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
  hole1Cushape->Z(2)    = hole1plastshape->GetZ(3);

  hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
  hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
  hole1Cushape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					 hole1Cushape->GetRmax(3));

  TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);

  hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
  hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
  hole1glassshape->Z(0)    = hole1Cushape->GetZ(1);

  dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;

  hole1glassshape->Rmin(1) = dza;
  hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
  hole1glassshape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					    hole1glassshape->GetRmin(1));

  hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
  hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
  hole1glassshape->Z(2)    = hole1Cushape->GetZ(3);

  hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
  hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
  hole1glassshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					    hole1glassshape->GetRmax(3));
  //
  TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
  hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
  hole2plastshape->Z(0)    = hole2shape->GetZ(0);

  hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
  hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
  hole2plastshape->Z(1)    = hole2shape->GetZ(1);

  dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;

  hole2plastshape->Rmin(2) = dza;
  hole2plastshape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					    hole2plastshape->GetRmin(2));
  hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
					    hole2plastshape->GetZ(2));

  hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
  hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
  hole2plastshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					    hole2plastshape->GetRmax(3));

  TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
  hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
  hole2Cushape->Z(0)    = hole2plastshape->GetZ(2);

  dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;

  hole2Cushape->Rmin(1) = dza;
  hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
  hole2Cushape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					 hole2Cushape->GetRmin(1));

  hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
  hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
  hole2Cushape->Z(2)    = hole2plastshape->GetZ(3);

  hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
  hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
  hole2Cushape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					 hole2Cushape->GetRmax(3));

  TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);

  hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
  hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
  hole2glassshape->Z(0)    = hole2Cushape->GetZ(1);

  dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;

  hole2glassshape->Rmin(1) = dza;
  hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
  hole2glassshape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
					    hole2glassshape->GetRmin(1));

  hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
  hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
  hole2glassshape->Z(2)    = hole2Cushape->GetZ(3);

  hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
  hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
  hole2glassshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
					    hole2glassshape->GetRmax(3));


  // Debug if requested
  if (GetDebug(1)) {
    coneshape->InspectShape();
    coneinsertshape->InspectShape();
    conefoamshape->InspectShape();
    hole1shape->InspectShape();
    hole2shape->InspectShape();
    hole3shape->InspectShape();
    hole4shape->InspectShape();
  }


  // We have the shapes: now create the real volumes

  TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone",
				      coneshape,medSDDcf);
  cfcone->SetVisibility(kTRUE);
  cfcone->SetLineColor(4); // Blue
  cfcone->SetLineWidth(1);
  cfcone->SetFillColor(cfcone->GetLineColor());
  cfcone->SetFillStyle(4000); // 0% transparent

  TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert",
					    coneinsertshape,medSDDste);
  cfconeinsert->SetVisibility(kTRUE);
  cfconeinsert->SetLineColor(2); // Red
  cfconeinsert->SetLineWidth(1);
  cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
  cfconeinsert->SetFillStyle(4050); // 50% transparent

  TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam",
					  conefoamshape,medSDDroh);
  cfconefoam->SetVisibility(kTRUE);
  cfconefoam->SetLineColor(7); // Light blue
  cfconefoam->SetLineWidth(1);
  cfconefoam->SetFillColor(cfconefoam->GetLineColor());
  cfconefoam->SetFillStyle(4050); // 50% transparent

  TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1",
				     hole1shape,medSDDair);
  hole1->SetVisibility(kTRUE);
  hole1->SetLineColor(5); // Yellow
  hole1->SetLineWidth(1);
  hole1->SetFillColor(hole1->GetLineColor());
  hole1->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
				      hole11shape,medSDDair);
  hole11->SetVisibility(kTRUE);
  hole11->SetLineColor(5); // Yellow
  hole11->SetLineWidth(1);
  hole11->SetFillColor(hole11->GetLineColor());
  hole11->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
				      hole12shape,medSDDair);
  hole12->SetVisibility(kTRUE);
  hole12->SetLineColor(5); // Yellow
  hole12->SetLineWidth(1);
  hole12->SetFillColor(hole12->GetLineColor());
  hole12->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
					  hole1plastshape,medSDDplast);
  hole1plast->SetVisibility(kTRUE);
  hole1plast->SetLineColor(kBlue);
  hole1plast->SetLineWidth(1);
  hole1plast->SetFillColor(hole1plast->GetLineColor());
  hole1plast->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
				       hole1Cushape,medSDDCu);
  hole1Cu->SetVisibility(kTRUE);
  hole1Cu->SetLineColor(kRed);
  hole1Cu->SetLineWidth(1);
  hole1Cu->SetFillColor(hole1Cu->GetLineColor());
  hole1Cu->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
					  hole1glassshape,medSDDglass);
  hole1glass->SetVisibility(kTRUE);
  hole1glass->SetLineColor(kGreen);
  hole1glass->SetLineWidth(1);
  hole1glass->SetFillColor(hole1glass->GetLineColor());
  hole1glass->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
				     hole2shape,medSDDair);
  hole2->SetVisibility(kTRUE);
  hole2->SetLineColor(5); // Yellow
  hole2->SetLineWidth(1);
  hole2->SetFillColor(hole2->GetLineColor());
  hole2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
				      hole21shape,medSDDair);
  hole21->SetVisibility(kTRUE);
  hole21->SetLineColor(5); // Yellow
  hole21->SetLineWidth(1);
  hole21->SetFillColor(hole21->GetLineColor());
  hole21->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
				      hole22shape,medSDDair);
  hole22->SetVisibility(kTRUE);
  hole22->SetLineColor(5); // Yellow
  hole22->SetLineWidth(1);
  hole22->SetFillColor(hole22->GetLineColor());
  hole22->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
					  hole2plastshape,medSDDplast);
  hole2plast->SetVisibility(kTRUE);
  hole2plast->SetLineColor(kBlue);
  hole2plast->SetLineWidth(1);
  hole2plast->SetFillColor(hole2plast->GetLineColor());
  hole2plast->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
				       hole2Cushape,medSDDCu);
  hole2Cu->SetVisibility(kTRUE);
  hole2Cu->SetLineColor(kRed);
  hole2Cu->SetLineWidth(1);
  hole2Cu->SetFillColor(hole2Cu->GetLineColor());
  hole2Cu->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
					  hole2glassshape,medSDDglass);
  hole2glass->SetVisibility(kTRUE);
  hole2glass->SetLineColor(kGreen);
  hole2glass->SetLineWidth(1);
  hole2glass->SetFillColor(hole2glass->GetLineColor());
  hole2glass->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
				     hole3shape,medSDDair);
  hole3->SetVisibility(kTRUE);
  hole3->SetLineColor(5); // Yellow
  hole3->SetLineWidth(1);
  hole3->SetFillColor(hole3->GetLineColor());
  hole3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
				      hole31shape,medSDDair);
  hole31->SetVisibility(kTRUE);
  hole31->SetLineColor(5); // Yellow
  hole31->SetLineWidth(1);
  hole31->SetFillColor(hole31->GetLineColor());
  hole31->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
				      hole32shape,medSDDair);
  hole32->SetVisibility(kTRUE);
  hole32->SetLineColor(5); // Yellow
  hole32->SetLineWidth(1);
  hole32->SetFillColor(hole32->GetLineColor());
  hole32->SetFillStyle(4090); // 90% transparent

  TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
				     hole4shape,medSDDair);
  hole4->SetVisibility(kTRUE);
  hole4->SetLineColor(5); // Yellow
  hole4->SetLineWidth(1);
  hole4->SetFillColor(hole4->GetLineColor());
  hole4->SetFillStyle(4090); // 90% transparent

  // Mount up a cone
  cfconeinsert->AddNode(cfconefoam,1,0);

  hole1->AddNode(hole1plast, 1, 0);
  hole1->AddNode(hole1Cu, 1, 0);
  hole1->AddNode(hole1glass, 1, 0);

  hole2->AddNode(hole2plast, 1, 0);
  hole2->AddNode(hole2Cu, 1, 0);
  hole2->AddNode(hole2glass, 1, 0);

  for (Int_t i=0; i<12; i++) {
    Double_t phiH = i*30.0;
    cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
        cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
        cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
  }

  for (Int_t i=0; i<6; i++) {
    Double_t phiH = i*60.0;
    cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
        cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
        cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
  }

  for (Int_t i=0; i<kNHole3; i++) {
    Double_t phiH0 = 360./(Double_t)kNHole3;
    Double_t phiH  = i*phiH0 + 0.5*phiH0;
    cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
        cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
        cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
  }

  cfcone->AddNode(cfconeinsert,1,0);

/*
  for (Int_t i=0; i<kNHole4; i++) {
    Double_t phiH0 = 360./(Double_t)kNHole4;
    Double_t phiH  = i*phiH0 + 0.25*phiH0;
    cfcone->AddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0));
  }
*/
  // Finally put everything in the mother volume
  moth->AddNode(cfcylinder,1,0);

  z = coneshape->Z(9);
  moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength));
  moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0,  z + kCylinderHalfLength,
			 new TGeoRotation("", 0, 180, 0)                   ));


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SSD support cone and cylinder geometry. as a
// volume assembly and adds it to the mother volume
// (part of this code is taken or anyway inspired to SSDCone method
// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      08 Mar 2008  Mario Sitta
//
// Technical data are taken from:  "ITS Supporto Generale" (technical
// drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale
// Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private
// communication with B. Giraudo
//
// Updated:      11 Apr 2008  Mario Sitta
// Measures from drawings give overlaps with SPD thermal shield wings,
// so the terminal part of the SSD cone was reduced
//
// Updated:      30 Mar 2010  Mario Sitta
// Following M. van Leeuwen's suggestion on material budget, the thickness
// of the carbon fiber cylinder was increased from 0.6 to 0.625mm

  // Dimensions of the Central cylinder and flanges
  const Double_t kCylinderHalfLength   = (1143.6/2) *fgkmm;
  const Double_t kCylinderOuterRadius  = ( 595.0/2) *fgkmm;
  const Double_t kCylinderThickness    =       0.625*fgkmm;
  const Double_t kFoamHalfLength       = (1020.0/2) *fgkmm;
  const Double_t kFoamThickness        =        5.0 *fgkmm;
  const Double_t kFlangeHalfLength     =
                                      (kCylinderHalfLength-kFoamHalfLength)/2.;
  const Double_t kFlangeInnerRadius    = ( 563.0/2) *fgkmm;
  // Dimensions of the Cone
  const Double_t kConeROuterMin        = ( 957.0/2) *fgkmm;
  const Double_t kConeROuterMax        = ( 997.0/2) *fgkmm;
  const Double_t kConeRInnerMin        = ( 564.0/2) *fgkmm;
  const Double_t kConeRCurv1           =       10.0 *fgkmm;
  const Double_t kConeRCurv2           =       25.0 *fgkmm;
  const Double_t kConeCent1RCurv2      = ( 578.0/2) *fgkmm;
  const Double_t kConeCent2RCurv2      = ( 592.0/2) *fgkmm;
//  const Double_t kConeZOuterRing       =       47.0 *fgkmm;
//  const Double_t kConeZOuterRingInside =       30.25*fgkmm;
//  const Double_t kConeZInnerRing       =      161.5 *fgkmm;
//  const Double_t kConeZLength          =      176.5 *fgkmm;
  const Double_t kConeZOuterRing       =       38.5 *fgkmm;
  const Double_t kConeZOuterRingInside =       22.2 *fgkmm;
  const Double_t kConeZInnerRing       =      153.0 *fgkmm;
  const Double_t kConeZLength          =      168.0 *fgkmm;
  const Double_t kConeZPosition        = kConeZLength + kCylinderHalfLength;
  const Double_t kConeThickness        =       13.0 *fgkmm; // Cone thickness
  const Double_t kConeTheta            =       39.1 *fgkDegree; // Cone angle
  const Double_t kSinConeTheta         =
                                      TMath::Sin(kConeTheta*TMath::DegToRad());
  const Double_t kCosConeTheta         =
                                      TMath::Cos(kConeTheta*TMath::DegToRad());
  // Dimensions of the Foam cores
  const Double_t kConeFoam1Length      =      112.3 *fgkmm;
  const Double_t kConeFoam2Length      =       58.4 *fgkmm;
  // Dimensions of the Cone Holes
  const Double_t kCoolingHoleWidth     =       40.0 *fgkmm;
  const Double_t kCoolingHoleHight     =       30.0 *fgkmm;
  const Double_t kCoolingHoleRmin      =      350.0 *fgkmm;
  const Double_t kCoolingHolePhi       =       45.0 *fgkDegree;
  const Double_t kMountingHoleWidth    =       20.0 *fgkmm;
  const Double_t kMountingHoleHight    =       20.0 *fgkmm;
  const Double_t kMountingHoleRmin     =      317.5 *fgkmm;
  const Double_t kMountingHolePhi      =       60.0 *fgkDegree;
  const Double_t kCableHoleRin         = ( 800.0/2) *fgkmm;
  const Double_t kCableHoleRout        = ( 920.0/2) *fgkmm;
  const Double_t kCableHoleWidth       =      200.0 *fgkmm;
//  const Double_t kCableHoleAngle       =       42.0 *fgkDegree;
  // Dimensions of the Cone Wings
  const Double_t kWingRmax             =      527.5 *fgkmm;
  const Double_t kWingWidth            =       70.0 *fgkmm;
  const Double_t kWingHalfThick        = (  10.0/2) *fgkmm;
  const Double_t kThetaWing            =       45.0 *fgkDegree;
  // Dimensions of the SSD-SDD Mounting Brackets
  const Double_t kBracketRmin          = ( 541.0/2) *fgkmm;// See SDD ROutMin
  const Double_t kBracketRmax          = ( 585.0/2) *fgkmm;
  const Double_t kBracketHalfLength    = (   4.0/2) *fgkmm;
  const Double_t kBracketPhi           = (70.*fgkmm/kBracketRmax)*fgkRadian;
  // Common data
  const Double_t kCFThickness          =        0.75*fgkmm; //Carb. fib. thick.


  // Local variables
  Double_t rmin1, rmin2, rmax, z;

  //
  //Begin_Html
  /*
    <img src="picts/ITS/file_name.gif">
    <P>
    <FONT FACE'"TIMES">
    ITS SSD central support and thermal shield cylinder.
    </FONT>
    </P>
  */
  //End_Html
  //

  // Central cylinder with its internal foam and the lateral flanges:
  // a carbon fiber Pcon which contains a rohacell Tube and two
  // stesalite Cone's
  TGeoPcon *externalcylshape = new TGeoPcon(0,360,4);

  rmax  = kCylinderOuterRadius;
  rmin1 = kFlangeInnerRadius - kCylinderThickness;
  rmin2 = rmax - 2*kCylinderThickness - kFoamThickness;
  externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax);
  externalcylshape->DefineSection(1,-kFoamHalfLength    ,rmin2,rmax);
  externalcylshape->DefineSection(2, kFoamHalfLength    ,rmin2,rmax);
  externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax);

  rmax  = kCylinderOuterRadius - kCylinderThickness;
  rmin1 = rmax - kFoamThickness;
  TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength);

  rmax  = kCylinderOuterRadius - kCylinderThickness;
  rmin1 = rmax - kFoamThickness;
  rmin2 = kFlangeInnerRadius;
  TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength,
				       rmin1,rmax,rmin2,rmax);


  // We have the shapes: now create the real volumes

  TGeoMedium *medSSDcf  = mgr->GetMedium("ITS_SSD C (M55J)$");
  TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$");
  TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
  TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$");
  TGeoMedium *medSSDal  = mgr->GetMedium("ITS_ALUMINUM$");

  TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder",
					   externalcylshape,medSSDcf);
  cfcylinder->SetVisibility(kTRUE);
  cfcylinder->SetLineColor(4); // blue
  cfcylinder->SetLineWidth(1);
  cfcylinder->SetFillColor(cfcylinder->GetLineColor());
  cfcylinder->SetFillStyle(4000); // 0% transparent

  TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder",
					    foamshape,medSSDroh);
  foamcylinder->SetVisibility(kTRUE);
  foamcylinder->SetLineColor(3); // green
  foamcylinder->SetLineWidth(1);
  foamcylinder->SetFillColor(foamcylinder->GetLineColor());
  foamcylinder->SetFillStyle(4050); // 50% transparent

  TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder",
					      flangeshape,medSSDste);
  flangecylinder->SetVisibility(kTRUE);
  flangecylinder->SetLineColor(2); // red
  flangecylinder->SetLineWidth(1);
  flangecylinder->SetFillColor(flangecylinder->GetLineColor());
  flangecylinder->SetFillStyle(4050); // 50% transparent

  // Mount up the cylinder
  cfcylinder->AddNode(foamcylinder,1,0);
  cfcylinder->AddNode(flangecylinder,1,
	      new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength));
  cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
              0, 0, -kFoamHalfLength-kFlangeHalfLength,
	      new TGeoRotation("",0,180,0)     ) );


  // The whole Cone as an assembly
  TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone");


  // SSD Support Cone with its internal inserts: a carbon fiber Pcon
  // with holes which contains a stesalite Pcon which on turn contains a
  // rohacell Pcon
  TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);

  coneshape->Z(0)     = 0.0;
  coneshape->Rmin(0)  = kConeROuterMin;
  coneshape->Rmax(0)  = kConeROuterMax;

  coneshape->Z(1)     = kConeZOuterRingInside - kConeRCurv1;
  coneshape->Rmin(1)  = coneshape->GetRmin(0);
  coneshape->Rmax(1)  = coneshape->GetRmax(0);

  coneshape->Z(2)     = kConeZOuterRingInside;
  coneshape->Rmin(2)  = coneshape->GetRmin(1) - kConeRCurv1;
  coneshape->Rmax(2)  = coneshape->GetRmax(0);

  coneshape->Z(3)     = coneshape->GetZ(2);
  coneshape->Rmax(3)  = coneshape->GetRmax(0);

  coneshape->Z(4)     = kConeZOuterRing - kConeRCurv1;
  coneshape->Rmax(4)  = coneshape->GetRmax(0);

  coneshape->Z(5)     = kConeZOuterRing;
  coneshape->Rmax(5)  = coneshape->GetRmax(4) - kConeRCurv1;

  coneshape->Z(6)     = coneshape->GetZ(5);

  RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2,
		    90.0-kConeTheta,z,rmin1);
  coneshape->Z(7)     = z;
  coneshape->Rmin(7)  = rmin1;

  coneshape->Rmin(3)  = RminFromZpCone(coneshape,7,90.-kConeTheta,
				       coneshape->GetZ(3));

  coneshape->Rmin(4)  = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4));

  coneshape->Rmin(5)  = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5));

  coneshape->Rmin(6) = coneshape->GetRmin(5);

  coneshape->Z(8)     = kConeZInnerRing;
  coneshape->Rmin(8)  = kConeCent1RCurv2;

  coneshape->Z(9)     = coneshape->GetZ(8);
  coneshape->Rmin(9)  = kConeRInnerMin;

  RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2,
		    90.0-kConeTheta,z,rmax);

  coneshape->Z(10)    = z;
  coneshape->Rmin(10) = coneshape->GetRmin(9);
  coneshape->Rmax(10) = rmax;

  coneshape->Rmax(6)  = RmaxFromZpCone(coneshape,10,90.-kConeTheta,
				       coneshape->GetZ(6));

  coneshape->Rmax(7)  = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7));

  coneshape->Rmax(8)  = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8));

  coneshape->Rmax(9)  = coneshape->GetRmax(8);

  coneshape->Z(11)    = kConeZLength;
  coneshape->Rmin(11) = coneshape->GetRmin(10);
  coneshape->Rmax(11) = kConeCent2RCurv2;

  // SSD Cone Insert: another Pcon
  Double_t x0, y0, x1, y1, x2, y2;
  TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12);

  coneinsertshape->Z(0)     = coneshape->GetZ(0) + kCFThickness;
  coneinsertshape->Rmin(0)  = coneshape->GetRmin(0) + kCFThickness;
  coneinsertshape->Rmax(0)  = coneshape->GetRmax(0) - kCFThickness;

  x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
  x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
  x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(1)     = z;
  coneinsertshape->Rmin(1)  = rmin1;
  coneinsertshape->Rmax(1)  = coneinsertshape->GetRmax(0);

  x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1);
  x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2);
  x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(2)     = z;
  coneinsertshape->Rmin(2)  = rmin1;
  coneinsertshape->Rmax(2)  = coneinsertshape->GetRmax(1);

  x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
  x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
  x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(3)     = z;
  coneinsertshape->Rmin(3)  = rmin1;
  coneinsertshape->Rmax(3)  = coneinsertshape->GetRmax(2);

  x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
  x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
  x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
  coneinsertshape->Z(4)     = z;
  coneinsertshape->Rmax(4)  = rmax;

  x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4);
  x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5);
  x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
  coneinsertshape->Z(5)     = z;
  coneinsertshape->Rmax(5)  = rmax;

  x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5);
  x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6);
  x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
  coneinsertshape->Z(6)     = z;
  coneinsertshape->Rmax(6)  = rmax;

  x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6);
  x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7);
  x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(7)     = z;
  coneinsertshape->Rmin(7)  = rmin1;

  coneinsertshape->Rmin(4)  = RminFrom2Points(coneinsertshape,3,7,
					      coneinsertshape->GetZ(4));

  coneinsertshape->Rmin(5)  = RminFrom2Points(coneinsertshape,3,7,
					      coneinsertshape->GetZ(5));

  coneinsertshape->Rmin(6)  = coneinsertshape->GetRmin(5);

  x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7);
  x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8);
  x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(8)     = z;
  coneinsertshape->Rmin(8)  = rmin1;

  x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8);
  x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9);
  x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10);
  InsidePoint(x0, y0, x1, y1, x2, y2,  kCFThickness, z, rmin1);
  coneinsertshape->Z(9)     = z;
  coneinsertshape->Rmin(9)  = rmin1;

  x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9);
  x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10);
  x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
  coneinsertshape->Z(10)    = z;
  coneinsertshape->Rmax(10) = rmax;
  coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9);

  coneinsertshape->Rmax(7)  = RmaxFrom2Points(coneinsertshape,6,10,
					      coneinsertshape->GetZ(7));

  coneinsertshape->Rmax(8)  = RmaxFrom2Points(coneinsertshape,6,10,
					      coneinsertshape->GetZ(8));

  coneinsertshape->Rmax(9)  = coneinsertshape->GetRmax(8);

  x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10);
  x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11);
  x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11);
  InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
  coneinsertshape->Z(11)    = z;
  coneinsertshape->Rmax(11) = rmax;
  coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10);

  // SSD Cone Foams: two other Pcon's
  TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4);

  conefoam1shape->Z(0)    = coneinsertshape->GetZ(3);
  conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3);
  conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0);

  conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0);
  conefoam1shape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					   conefoam1shape->GetRmax(1));
  conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
					   conefoam1shape->GetZ(1));

  Double_t t = kConeThickness - 2*kCFThickness;
  conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) -
                           (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta);
  conefoam1shape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					   conefoam1shape->GetRmin(2));
  conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
					   conefoam1shape->GetZ(2));

  conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2);
  conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3);
  conefoam1shape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					   conefoam1shape->GetRmax(3));

  TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4);

  conefoam2shape->Z(3)    = coneinsertshape->GetZ(10);
  conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10);
  conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3);

  conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3);
  conefoam2shape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					   conefoam2shape->GetRmin(2));
  conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
					   conefoam2shape->GetZ(2));

  conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) +
                           (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta);
  conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0);
  conefoam2shape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					   conefoam2shape->GetRmin(0));

  conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0);
  conefoam2shape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					   conefoam2shape->GetRmax(1));
  conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
					   conefoam2shape->GetZ(1));

  // SSD Cone Holes: Pcon's
  // A single hole volume gives an overlap with coneinsert, so
  // three contiguous volumes are created: one to be put in coneinsert
  // and two in the cone carbon fiber envelope
  Double_t holePhi;
  holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();

  TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);

  coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
  coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
  coolingholeshape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					     coolingholeshape->GetRmin(0));

  coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
  coolingholeshape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					     coolingholeshape->GetRmax(1));
  coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
					     coolingholeshape->GetZ(1));

  coolingholeshape->Rmin(2) = kCoolingHoleRmin;
  coolingholeshape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					     coolingholeshape->GetRmin(2));
  coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
					     coolingholeshape->GetZ(2));

  coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
  coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
  coolingholeshape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					     coolingholeshape->GetRmax(3));

  TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
  coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
  coolinghole2shape->Z(0)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
					      coolinghole2shape->GetRmin(0));

  coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
  coolinghole2shape->Z(1)    = coolingholeshape->GetZ(0);
  coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
					      coolinghole2shape->GetZ(1));

  coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
  coolinghole2shape->Z(2)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
					      coolinghole2shape->GetRmin(2));
  coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
					      coolinghole2shape->GetZ(2));

  coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
  coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
  coolinghole2shape->Z(3)    = coolingholeshape->GetZ(2);

  TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
  coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
  coolinghole3shape->Z(0)    = coolingholeshape->GetZ(1);

  coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
  coolinghole3shape->Z(1)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
					      coolinghole3shape->GetRmax(1));
  coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
					      coolinghole3shape->GetZ(1));

  coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
  coolinghole3shape->Z(2)    = coolingholeshape->GetZ(3);
  coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
					      coolinghole3shape->GetZ(2));

  coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
  coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
  coolinghole3shape->Z(3)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
					      coolinghole3shape->GetRmax(3));

  //
  holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();

  TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);

  mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
  mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0);
  mountingholeshape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					      mountingholeshape->GetRmin(0));

  mountingholeshape->Rmin(1) = kMountingHoleRmin;
  mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0);
  mountingholeshape->Z(1)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
					      mountingholeshape->GetRmin(1));

  mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1);
  mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1);
  mountingholeshape->Z(2)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					      mountingholeshape->GetRmax(2));

  mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2);
  mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3);
  mountingholeshape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
					      mountingholeshape->GetRmax(3));

  TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
  mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0);
  mountinghole2shape->Z(0)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
					       mountinghole2shape->GetRmin(0));

  mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0);
  mountinghole2shape->Z(1)    = mountingholeshape->Z(0);
  mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
					       mountinghole2shape->GetZ(1));

  mountinghole2shape->Rmin(2) = kMountingHoleRmin;
  mountinghole2shape->Z(2)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
					       mountinghole2shape->GetRmin(2));
  mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
					       mountinghole2shape->GetZ(2));

  mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2);
  mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3);
  mountinghole2shape->Z(3)    = mountingholeshape->Z(1);

  TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);

  mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
  mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0);
  mountinghole3shape->Z(0)    = mountingholeshape->GetZ(2);

  mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0);
  mountinghole3shape->Z(1)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
					       mountinghole3shape->GetRmax(1));
  mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
					       mountinghole3shape->GetZ(1));

  mountinghole3shape->Rmin(2) = kMountingHoleRmin;
  mountinghole3shape->Z(2)    = mountingholeshape->Z(3);
  mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
					       mountinghole3shape->GetZ(2));

  mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2);
  mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3);
  mountinghole3shape->Z(3)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
					       mountinghole3shape->GetRmax(3));

  // The Cable Hole is even more complicated, a Composite Shape
  // is unavoidable here (gosh!)
  TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12);

  for (Int_t i=0; i<12; i++) {
    coneshapecopy->Rmin(i) = coneshape->GetRmin(i);
    coneshapecopy->Rmax(i) = coneshape->GetRmax(i);
    coneshapecopy->Z(i)    = coneshape->GetZ(i);
  }

  holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg();
  TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength,
				      kCableHoleRin, kCableHoleRout,
				      kCableHoleRin, kCableHoleRout,
				      -0.5*holePhi, 0.5*holePhi);

  TGeoCompositeShape *cableholeshape = new TGeoCompositeShape(
					   "SSDCableHoleShape",
					   "conecopy*chCS");

  if(GetDebug(1)){
    chCS->InspectShape();
    cableholeshape->InspectShape();
  }

  // SSD Cone Wings: Tube and TubeSeg shapes
  Double_t angleWideWing, angleWideWingThickness;
  angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg();
  angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg();

  TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax,
					   kWingHalfThick,
					   0, angleWideWing);

  TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax,
				 kWingRmax-kCFThickness,
				 kWingHalfThick-kCFThickness,
				 angleWideWingThickness,
				 angleWideWing-angleWideWingThickness);

  // SDD support plate, SSD side (Mounting Bracket): a TubeSeg
  TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax,
                            kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2);


  // We have the shapes: now create the real volumes

  TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone",
				      coneshape,medSSDcf);
  cfcone->SetVisibility(kTRUE);
  cfcone->SetLineColor(4); // Blue
  cfcone->SetLineWidth(1);
  cfcone->SetFillColor(cfcone->GetLineColor());
  cfcone->SetFillStyle(4000); // 0% transparent

  TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert",
					    coneinsertshape,medSSDste);
  cfconeinsert->SetVisibility(kTRUE);
  cfconeinsert->SetLineColor(2); // Red
  cfconeinsert->SetLineWidth(1);
  cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
  cfconeinsert->SetFillStyle(4050); // 50% transparent

  TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1",
					    conefoam1shape,medSSDroh);
  cfconefoam1->SetVisibility(kTRUE);
  cfconefoam1->SetLineColor(3); // Green
  cfconefoam1->SetLineWidth(1);
  cfconefoam1->SetFillColor(cfconefoam1->GetLineColor());
  cfconefoam1->SetFillStyle(4050); // 50% transparent

  TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2",
					    conefoam2shape,medSSDroh);
  cfconefoam2->SetVisibility(kTRUE);
  cfconefoam2->SetLineColor(3); // Green
  cfconefoam2->SetLineWidth(1);
  cfconefoam2->SetFillColor(cfconefoam2->GetLineColor());
  cfconefoam2->SetFillStyle(4050); // 50% transparent

  TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole",
					   coolingholeshape,medSSDair);
  coolinghole->SetVisibility(kTRUE);
  coolinghole->SetLineColor(5); // Yellow
  coolinghole->SetLineWidth(1);
  coolinghole->SetFillColor(coolinghole->GetLineColor());
  coolinghole->SetFillStyle(4090); // 90% transparent

  TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
					    coolinghole2shape,medSSDair);
  coolinghole2->SetVisibility(kTRUE);
  coolinghole2->SetLineColor(5); // Yellow
  coolinghole2->SetLineWidth(1);
  coolinghole2->SetFillColor(coolinghole2->GetLineColor());
  coolinghole2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
					    coolinghole3shape,medSSDair);
  coolinghole3->SetVisibility(kTRUE);
  coolinghole3->SetLineColor(5); // Yellow
  coolinghole3->SetLineWidth(1);
  coolinghole3->SetFillColor(coolinghole3->GetLineColor());
  coolinghole3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
					    mountingholeshape,medSSDair);
  mountinghole->SetVisibility(kTRUE);
  mountinghole->SetLineColor(5); // Yellow
  mountinghole->SetLineWidth(1);
  mountinghole->SetFillColor(mountinghole->GetLineColor());
  mountinghole->SetFillStyle(4090); // 90% transparent

  TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2",
					     mountinghole2shape,medSSDair);
  mountinghole2->SetVisibility(kTRUE);
  mountinghole2->SetLineColor(5); // Yellow
  mountinghole2->SetLineWidth(1);
  mountinghole2->SetFillColor(mountinghole2->GetLineColor());
  mountinghole2->SetFillStyle(4090); // 90% transparent

  TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3",
					     mountinghole3shape,medSSDair);
  mountinghole3->SetVisibility(kTRUE);
  mountinghole3->SetLineColor(5); // Yellow
  mountinghole3->SetLineWidth(1);
  mountinghole3->SetFillColor(mountinghole3->GetLineColor());
  mountinghole3->SetFillStyle(4090); // 90% transparent

  TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf);
  wing->SetVisibility(kTRUE);
  wing->SetLineColor(4); // Blue
  wing->SetLineWidth(1);
  wing->SetFillColor(wing->GetLineColor());
  wing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *cablehole = new TGeoVolume("SSDCableHole",
					 cableholeshape,medSSDair);
  cablehole->SetVisibility(kTRUE);
  cablehole->SetLineColor(5); // Yellow
  cablehole->SetLineWidth(1);
  cablehole->SetFillColor(cablehole->GetLineColor());
  cablehole->SetFillStyle(4090); // 90% transparent

  TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert",
					  winginsertshape,medSSDste);
  winginsert->SetVisibility(kTRUE);
  winginsert->SetLineColor(2); // Red
  winginsert->SetLineWidth(1);
  winginsert->SetFillColor(winginsert->GetLineColor());
  winginsert->SetFillStyle(4050); // 50% transparent

  TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket",
				       bracketshape,medSSDal);
  bracket->SetVisibility(kTRUE);
  bracket->SetLineColor(6); // Purple
  bracket->SetLineWidth(1);
  bracket->SetFillColor(bracket->GetLineColor());
  bracket->SetFillStyle(4000); // 0% transparent

  // Mount up a cone
  for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
    Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
    cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
  }

  for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
    Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
    cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
  }

  cfconeinsert->AddNode(cfconefoam1,1,0);
  cfconeinsert->AddNode(cfconefoam2,1,0);

  cfcone->AddNode(cfconeinsert,1,0);

  for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
    Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
    cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
    cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
    cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
  }

  for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
    Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
    cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
    cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
  }

  wing->AddNode(winginsert,1,0);

  // Add all volumes in the Cone assembly
  vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));

  for (Int_t i=0; i<4; i++) {
    Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
    vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
			   new TGeoRotation("",thetaW,180,0)));
  }

  Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
                      2*bracketshape->GetDz();
  for (Int_t i=0; i<3; i++) {
    Double_t thetaB = 60 + 120.*i;
    vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
			      new TGeoRotation("",thetaB,0,0)));
  }

  // Finally put everything in the mother volume
  moth->AddNode(cfcylinder,1,0);

  moth->AddNode(vC, 1, 0 );
  moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) );

  // Some debugging if requested
  if(GetDebug(1)){
    vC->PrintNodes();
    vC->InspectShape();
  }

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
                                                    TGeoManager *mgr){
//
// Creates the cable trays which are outside the ITS support cones
// but still inside the TPC
// This is now a stearing routine, the actual work is done by three
// specialized methods to avoid a really huge unique method
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:      15 Nov 2009  Mario Sitta
//

  TraySupportsSideA(moth, mgr);

  ServicesCableSupportSPD(moth, mgr);
  ServicesCableSupportSDD(moth, mgr);
  ServicesCableSupportSSD(moth, mgr);

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
					   const TGeoManager *mgr){
//
// Creates the structure supporting the ITS cable trays on Side A
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:      14 Dec 2009  Mario Sitta
// Updated:      26 Feb 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
//

  // Dimensions and positions of the A-Side Cable Tray Support Ring
  // (0872/G/A/01)
  const Double_t kSuppRingYTrans      =  110.00 *fgkmm;
  const Double_t kSuppRingZTrans      =(1011.00+435.00) *fgkmm;
  const Double_t kSuppForwYTrans      =  185.00 *fgkmm;

  const Double_t kExtSuppRingSpace1   =   33.00 *fgkmm;
  const Double_t kExtSuppRingSpace2   =   45.00 *fgkmm;
  const Double_t kExtSuppRingSpcAbov  =   30.00 *fgkmm;
  const Double_t kExtSuppRingBase     =  491.50 *fgkmm;
  const Double_t kExtSuppRingInward   =   35.00 *fgkmm;
  const Double_t kExtSuppRingRmax     =  540.00 *fgkmm;
  const Double_t kExtSuppRingRint1    =  465.00 *fgkmm;
  const Double_t kExtSuppRingRint2    =  467.00 *fgkmm;
  const Double_t kExtSuppRingInnerHi  =  450.00 *fgkmm;
  const Double_t kExtSuppRingInWide   =  100.00 *fgkmm;
  const Double_t kExtSuppRingR7       =    7.00 *fgkmm;
  const Double_t kExtSuppRingR5       =    5.00 *fgkmm;
  const Double_t kExtSuppRingThick    =   20.00 *fgkmm;

  const Double_t kExtSuppRingSpcAng   =   10.50 *TMath::DegToRad();
  const Double_t kExtSuppRingPartPhi  =   15.00 *TMath::DegToRad();
  const Double_t kExtSuppRingIntAng   =    7.00 *TMath::DegToRad();
  const Double_t kExtSuppRingBaseAng  =   75.00 *TMath::DegToRad();
  const Double_t kExtSuppRingR7Ang    =  100.00 *TMath::DegToRad(); // Guessed

  const Int_t    kExtSuppRingNPtsArc  =   10; // N.points to approximate arc

  const Double_t kIntSuppRingThick1   =   15.00 *fgkmm;
  const Double_t kIntSuppRingThick2   =   13.00 *fgkmm;
  const Double_t kIntSuppRingInward   =   24.00 *fgkmm;
  const Double_t kIntSuppRingThick    =   20.00 *fgkmm;

  const Double_t kSuppCylHeight       =  340.00 *fgkmm;
  const Double_t kSuppCylRint         =  475.00 *fgkmm;
  const Double_t kSuppCylRext         =  478.00 *fgkmm;
  const Double_t kSuppCylDispl        =  137.70 *fgkmm;

  const Double_t kSuppSpacerHeight    =   30.00 *fgkmm;
  const Double_t kSuppSpacerThick     =   10.00 *fgkmm;

  const Double_t kSuppSpacerAngle     =   15.00;  // Degrees

  const Double_t kSuppForwRingRint1   =  500.00 *fgkmm;
  const Double_t kSuppForwRingRint2   =  540.00 *fgkmm;
  const Double_t kSuppForwRingRext    =  560.00 *fgkmm;
  const Double_t kSuppForwRingThikAll =   50.00 *fgkmm;
  const Double_t kSuppForwRingThikInt =   20.00 *fgkmm;

  // (0872/G/B/01)
  const Double_t kSuppForwConeRmin    =  558.00 *fgkmm;
  const Double_t kSuppForwConeRmax    =  681.00 *fgkmm;
  const Double_t kSuppForwConeLen1    =  318.00 *fgkmm;
  const Double_t kSuppForwConeLen2    =  662.00 *fgkmm;
  const Double_t kSuppForwConeThick   =    3.00 *fgkmm;

  const Double_t kSuppBackRingPlacTop =   90.00 *fgkmm;
  const Double_t kSuppBackRingPlacSid =   50.00 *fgkmm;
  const Double_t kSuppBackRingHeight  =  760.00 *fgkmm;
  const Double_t kSuppBackRingRext    =  760.00 *fgkmm;
  const Double_t kSuppBackRingRint    =  685.00 *fgkmm;
//  const Double_t kSuppBackRingRint2   =  675.00 *fgkmm;
  const Double_t kSuppBackRingR10     =   10.00 *fgkmm;
  const Double_t kSuppBackRingBase    =  739.00 *fgkmm;
  const Double_t kSuppBackRingThikAll =   50.00 *fgkmm;
  const Double_t kSuppBackRingThick1  =   20.00 *fgkmm;
  const Double_t kSuppBackRingThick2  =   20.00 *fgkmm;

//  const Double_t kSuppBackRingPlacAng =   10.00 *TMath::DegToRad();
  const Double_t kSuppBackRingPlacAng =   10.25 *TMath::DegToRad();//Fix ovlp.
  const Double_t kSuppBackRing2ndAng1 =   78.40 *TMath::DegToRad();
  const Double_t kSuppBackRing2ndAng2 =   45.00 *TMath::DegToRad();

  const Int_t    kSuppBackRingNPtsArc =   10; // N.points to approximate arc

  // (0872/G/C/01)
  const Double_t kRearSuppZTransGlob  =(1011.00+9315.00-6040.00) *fgkmm;
  const Double_t kBackRodZTrans       = 2420.00 *fgkmm;

  const Double_t kBackRodLength       = 1160.00 *fgkmm;
  const Double_t kBackRodThickLen     =   20.00 *fgkmm;
  const Double_t kBackRodDiameter     =   20.00 *fgkmm;

  const Double_t kSuppRearRingRint    =  360.00 *fgkmm;
  const Double_t kSuppRearRingRext1   =  410.00 *fgkmm;
  const Double_t kSuppRearRingRext2   =  414.00 *fgkmm;
  const Double_t kSuppRearRingHeight  =  397.00 *fgkmm;
  const Double_t kSuppRearRingTopWide =  111.87 *fgkmm;
  const Double_t kSuppRearRingBase    =  451.50 *fgkmm;
  const Double_t kSuppRearRingBaseHi  =   58.00 *fgkmm;
  const Double_t kSuppRearRingSideHi  =   52.00 *fgkmm;
  const Double_t kSuppRearRingInside  =   40.00 *fgkmm;
  const Double_t kSuppRearRingInsideHi=   12.00 *fgkmm;
  const Double_t kSuppRearRingThick   =   20.00 *fgkmm;
  const Double_t kSuppRearRingXRodHole=  441.50 *fgkmm;
  const Double_t kSuppRearRingYRodHole=   42.00 *fgkmm;

  const Double_t kSuppRearRing1stAng  =   22.00 *TMath::DegToRad();
  const Double_t kSuppRearRingStepAng =   15.00 *TMath::DegToRad();

  const Int_t    kSuppRearRingNPtsArc =   10; // N.points to approximate arc


  // Local variables
  Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
  Double_t slp1, slp2, phi, xm, ym;
  Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
  Int_t npoints;


  // The whole support as an assembly
  TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
  

  // First create all needed shapes

  // The External Ring (part of 0872/G/A/01): a really complex Xtru
  TGeoXtru *extSuppRing = new TGeoXtru(2);

  // First the upper notch...
  xprof[ 0] = kExtSuppRingSpace1;
  yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;

  slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
  IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
		  xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym

  xprof[ 4] = xprof[5];
  yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
  xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
  yprof[ 3] = yprof[4] - kExtSuppRingR5*(    TMath::Sin(TMath::Pi()/6));
  xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
  yprof[ 2] = yprof[4] - kExtSuppRingR5*(    TMath::Sin(TMath::Pi()/3));
  xprof[ 1] = xprof[4] - kExtSuppRingR5;
  yprof[ 1] = yprof[4] - kExtSuppRingR5;

  Int_t indx = 5+kExtSuppRingNPtsArc;
  // ...then the external arc, approximated with segments,...
  xprof[indx] = kExtSuppRingBase;
  yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
			    kExtSuppRingBase*kExtSuppRingBase);
  Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
  Double_t alphamax = TMath::Pi()/2 -
		    TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);

  for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
    Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
    xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
    yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
  }
  // ...and finally the interior profile
  xprof[indx+1] = kExtSuppRingBase;
  yprof[indx+1] = kSuppRingYTrans;
  xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
  yprof[indx+2] = yprof[indx+1];

  phi  = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
  slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = kExtSuppRingRint2*TMath::Cos(phi);
  ym   = kExtSuppRingRint2*TMath::Sin(phi);
  IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
		 xprof[indx+3], yprof[indx+3]);

  slp1 = slp2;
  phi += kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = kExtSuppRingRint1*TMath::Cos(phi);
  ym   = kExtSuppRingRint1*TMath::Sin(phi);
  IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
		 xprof[indx+4], yprof[indx+4]);
  
  slp1 = slp2;
  phi += kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = kExtSuppRingRint2*TMath::Cos(phi);
  ym   = kExtSuppRingRint2*TMath::Sin(phi);
  IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
		 xprof[indx+5], yprof[indx+5]);
  
  slp1 = slp2;
  phi += kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = kExtSuppRingRint1*TMath::Cos(phi);
  ym   = kExtSuppRingRint1*TMath::Sin(phi);
  IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
		 xprof[indx+6], yprof[indx+6]);
  
  xprof[indx+9] = kExtSuppRingInWide;
  yprof[indx+9] = kExtSuppRingInnerHi;
  xprof[indx+8] = xprof[indx+9] +
		  (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
  yprof[indx+8] = yprof[indx+9] +
		  (    TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
  xprof[indx+7] = xprof[indx+9] +
		  (1 + TMath::Cos(kExtSuppRingR7Ang  ))*kExtSuppRingR7;
  yprof[indx+7] = yprof[indx+9] +
		  (    TMath::Sin(kExtSuppRingR7Ang  ))*kExtSuppRingR7;
  // Gosh, we did the right side! now reflex on the left side
  npoints = (sizeof(xprof)/sizeof(Double_t))/2;
  for (Int_t jp = 0; jp < npoints; jp++) {
    xprof[npoints+jp] = -xprof[npoints-1-jp];
    yprof[npoints+jp] =  yprof[npoints-1-jp];
  }
  // wow! now the actual Xtru
  extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
  extSuppRing->DefineSection(0,0);
  extSuppRing->DefineSection(1,kExtSuppRingThick);

  // The Internal Ring (part of 0872/G/A/01): another complex Xtru
  TGeoXtru *intSuppRing = new TGeoXtru(2);

  // First the external profile...
  npoints = 0;

  slp1 = 0;
  phi  = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
  ym   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
  IntersectLines(slp1,  0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  phi -= kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
  ym   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  phi -= kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
  ym   = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  phi -= kExtSuppRingPartPhi;
  slp2 = TMath::Tan(TMath::Pi()/2 + phi);
  xm   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
  ym   = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
  yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
				xprof[npoints]);
  npoints++;

  xprof[npoints] = xprof[npoints-1];
  yprof[npoints] = kSuppRingYTrans;
  npoints++;
  // ...and then the interior profile, which is identical to extSuppRing one
  for (Int_t jp=0; jp < 8; jp++) {
    xprof[npoints] = extSuppRing->GetX(17+jp);
    yprof[npoints] = extSuppRing->GetY(17+jp);
    npoints++;
  }
  // We did the right side! now reflex on the left side
  for (Int_t jp = 0; jp < npoints; jp++) {
    xprof[npoints+jp] = -xprof[npoints-1-jp];
    yprof[npoints+jp] =  yprof[npoints-1-jp];
  }
  // And now the actual Xtru
  intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
  intSuppRing->DefineSection(0,0);
  intSuppRing->DefineSection(1,kIntSuppRingThick);

  // The intermediate cylinder (0872/G/A/03): a TubeSeg
  alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
  alphamax = 180 - alphamin;
  TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
				     kSuppCylHeight/2, alphamin, alphamax);

  // The spacer (0872/G/A/03): a simple Xtru
  TGeoXtru *suppSpacer = new TGeoXtru(2);

  xprof[0] = kSuppSpacerHeight;
  yprof[0] = kSuppSpacerThick;
  xprof[1] = xprof[0];
  yprof[1] = 0;
  xprof[2] = 0;
  yprof[2] = 0;
  xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
  yprof[3] = yprof[0];

  suppSpacer->DefinePolygon(4, xprof, yprof);
  suppSpacer->DefineSection(0,-kSuppCylHeight/2);
  suppSpacer->DefineSection(1, kSuppCylHeight/2);

  // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
  Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
  alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
  alphamax = 180 - alphamin;

  TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);

  forwardRing->DefineSection(0,0,
			     kSuppForwRingRint1,kSuppForwRingRext);
  forwardRing->DefineSection(1,kSuppForwRingThikInt,
			     kSuppForwRingRint1,kSuppForwRingRext);
  forwardRing->DefineSection(2,kSuppForwRingThikInt,
			     kSuppForwRingRint2,kSuppForwRingRext);
  forwardRing->DefineSection(3,kSuppForwRingThikAll,
			     kSuppForwRingRint2,kSuppForwRingRext);

  // The forward cone (0872/G/B/03): a TGeoPcon
  TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);

  forwardCone->DefineSection(0,0,
			     kSuppForwConeRmin-kSuppForwConeThick,
			     kSuppForwConeRmin);
  forwardCone->DefineSection(1,kSuppForwConeLen1,
			     kSuppForwConeRmin-kSuppForwConeThick,
			     kSuppForwConeRmin);
  forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
			     kSuppForwConeRmax-kSuppForwConeThick,
			     kSuppForwConeRmax);

  // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
  TGeoXtru *firstSuppBackRing = new TGeoXtru(2);

  // First the external profile... (the arc is approximated with segments)
  npoints = 0;

  xprof[npoints] = kSuppBackRingPlacTop;
  yprof[npoints] = kSuppBackRingHeight;
  npoints++;

  alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
  alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);

  xprof[npoints] = xprof[npoints-1];
  yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
  npoints++;

  for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
    Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
    xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
    yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
    npoints++;
  }

  xprof[npoints] = kSuppBackRingBase -
		   kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
  yprof[npoints] = yprof[npoints-1];
  npoints++;

  xprof[npoints] = kSuppBackRingBase;
  yprof[npoints] = kSuppForwYTrans;
  npoints++;
  // ...then the internal profile (the arc is approximated with segments)
  alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
  alphamax = TMath::Pi()/2;

  for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
    Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
    xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
    yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
    npoints++;
  }

  xprof[npoints] = 0;
  yprof[npoints] = kSuppBackRingRint;
  npoints++;
  // We did the right side! now reflex on the left side (except last point)
  for (Int_t jp = 0; jp < npoints-1; jp++) {
    xprof[npoints+jp] = -xprof[npoints-jp-2];
    yprof[npoints+jp] =  yprof[npoints-jp-2];
  }
  // And now the actual Xtru
  firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
  firstSuppBackRing->DefineSection(0,0);
  firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);

  // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
  // (slight oversimplification)
  alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
  alphamax = 180 - alphamin;

  TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);

  deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
  rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
  rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
  secondSuppBackRing->DefineSection(0, 0, rmin, rmax);

  zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
  rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
  rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
  secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);

  zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
  rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
  rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
  secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);

  zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
  rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
  rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
  secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);

  slp1 = TMath::Tan(kSuppBackRing2ndAng2);
  slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
  IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
		  slp2,kSuppBackRingThikAll,deltaR,
		  xm, ym);

  zloc = xm - kSuppBackRingThick1;
  rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
  rmax = rmin + deltaR;
  secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);

  zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
  rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
  rmax = rmin + deltaR/2;
  secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);

  // The supporting rod: a Tube
  TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
				   (kBackRodLength - kBackRodThickLen)/2);

  // The Back Ring (0872/G/C/01): another complex Xtru
  TGeoXtru *suppRearRing = new TGeoXtru(2);

  // First the external profile...
  npoints = 0;

  xprof[npoints] = kSuppRearRingTopWide;
  yprof[npoints] = kSuppRearRingHeight;
  npoints++;

  phi = kSuppRearRing1stAng;
  slp1 = TMath::Tan(TMath::Pi() - phi);
  phi += kSuppRearRingStepAng;
  slp2 = TMath::Tan(TMath::Pi() - phi);
  xm = kSuppRearRingRext2*TMath::Sin(phi);
  ym = kSuppRearRingRext2*TMath::Cos(phi);
  IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  phi += kSuppRearRingStepAng;
  slp2 = TMath::Tan(TMath::Pi() - phi);
  xm = kSuppRearRingRext1*TMath::Sin(phi);
  ym = kSuppRearRingRext1*TMath::Cos(phi);
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  phi += kSuppRearRingStepAng;
  slp2 = TMath::Tan(TMath::Pi() - phi);
  xm = kSuppRearRingRext2*TMath::Sin(phi);
  ym = kSuppRearRingRext2*TMath::Cos(phi);
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  slp1 = slp2;
  slp2 = 0;
  xm = kSuppRearRingBase;
  ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
  IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
		 slp2, xm, ym,
		 xprof[npoints], yprof[npoints]);
  npoints++;

  xprof[npoints] = kSuppRearRingBase;
  yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
  npoints++;
  xprof[npoints] = xprof[npoints - 1];
  yprof[npoints] = kSuppRearRingBaseHi;
  npoints++;
  xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
  yprof[npoints] = yprof[npoints - 1];
  npoints++;
  xprof[npoints] = xprof[npoints - 1];
  yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
  npoints++;
  // ...then the internal arc, approximated with segments,...
  xprof[npoints] = kSuppRearRingRint;
  yprof[npoints] = yprof[npoints - 1];

  alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
  alphamax = TMath::Pi()/2;

  for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
    Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
    xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
    yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
  }

  xprof[npoints+kSuppRearRingNPtsArc] = 0;
  yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
  // We did the right side! now reflex on the left side
  Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
  for (Int_t jp = 0; jp < nTotalPoints; jp++) {
    xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
    yprof[nTotalPoints+1+jp] =  yprof[nTotalPoints-1-jp];
  }

  // And now the actual Xtru
  suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
  suppRearRing->DefineSection(0,0);
  suppRearRing->DefineSection(1,kSuppRearRingThick);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");

  TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
						 extSuppRing, medAl);

  sideAExtSuppRing->SetVisibility(kTRUE);
  sideAExtSuppRing->SetLineColor(kMagenta+1);
  sideAExtSuppRing->SetLineWidth(1);
  sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
  sideAExtSuppRing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
						 intSuppRing, medAl);

  sideAIntSuppRing->SetVisibility(kTRUE);
  sideAIntSuppRing->SetLineColor(kMagenta+1);
  sideAIntSuppRing->SetLineWidth(1);
  sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
  sideAIntSuppRing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
					    interCylind, medAl);

  sideASuppCyl->SetVisibility(kTRUE);
  sideASuppCyl->SetLineColor(kMagenta+1);
  sideASuppCyl->SetLineWidth(1);
  sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
  sideASuppCyl->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
					       suppSpacer, medAl);

  sideASuppSpacer->SetVisibility(kTRUE);
  sideASuppSpacer->SetLineColor(kMagenta+1);
  sideASuppSpacer->SetLineWidth(1);
  sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
  sideASuppSpacer->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
						 forwardRing, medAl);

  sideASuppForwRing->SetVisibility(kTRUE);
  sideASuppForwRing->SetLineColor(kMagenta+1);
  sideASuppForwRing->SetLineWidth(1);
  sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
  sideASuppForwRing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
						 forwardCone, medAl);

  sideASuppForwCone->SetVisibility(kTRUE);
  sideASuppForwCone->SetLineColor(kMagenta+1);
  sideASuppForwCone->SetLineWidth(1);
  sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
  sideASuppForwCone->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
						     firstSuppBackRing, medAl);

  sideAFirstSuppBackRing->SetVisibility(kTRUE);
  sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
  sideAFirstSuppBackRing->SetLineWidth(1);
  sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
  sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
						       secondSuppBackRing, medAl);

  sideASecondSuppBackRing->SetVisibility(kTRUE);
  sideASecondSuppBackRing->SetLineColor(kMagenta+1);
  sideASecondSuppBackRing->SetLineWidth(1);
  sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
  sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
					    suppRod, medAl);

  sideASuppRod->SetVisibility(kTRUE);
  sideASuppRod->SetLineColor(kMagenta+1);
  sideASuppRod->SetLineWidth(1);
  sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
  sideASuppRod->SetFillStyle(4000); // 0% transparent

  TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
						 suppRearRing, medAl);

  sideASuppRearRing->SetVisibility(kTRUE);
  sideASuppRearRing->SetLineColor(kMagenta+1);
  sideASuppRearRing->SetLineWidth(1);
  sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
  sideASuppRearRing->SetFillStyle(4000); // 0% transparent


  // Now build up the support structure
  zloc = kSuppRingZTrans;
  trayASuppStruct->AddNode(sideAExtSuppRing, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideAExtSuppRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += kExtSuppRingThick;
  trayASuppStruct->AddNode(sideAIntSuppRing, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideAIntSuppRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  xloc = kExtSuppRingBase - kIntSuppRingInward;
  yloc = kSuppRingYTrans;
  zloc += (kIntSuppRingThick + kSuppCylHeight/2);
  trayASuppStruct->AddNode(sideASuppCyl, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideASuppCyl, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));
  trayASuppStruct->AddNode(sideASuppSpacer, 1,
			   new TGeoCombiTrans( xloc, yloc, zloc,
			   new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
  trayASuppStruct->AddNode(sideASuppSpacer, 2,
			   new TGeoCombiTrans(-xloc, yloc, zloc,
			   new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
  trayASuppStruct->AddNode(sideASuppSpacer, 3,
			   new TGeoCombiTrans( xloc,-yloc, zloc,
			   new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
  trayASuppStruct->AddNode(sideASuppSpacer, 4,
			   new TGeoCombiTrans(-xloc,-yloc, zloc,
			   new TGeoRotation("",270+kSuppSpacerAngle,0,0)));


  zloc += kSuppCylHeight/2;
  trayASuppStruct->AddNode(sideAIntSuppRing, 3,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideAIntSuppRing, 4,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += kIntSuppRingThick;
  trayASuppStruct->AddNode(sideAExtSuppRing, 3,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideAExtSuppRing, 4,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += kExtSuppRingThick;
  trayASuppStruct->AddNode(sideASuppForwRing, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideASuppForwRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += kSuppForwRingThikAll;
  trayASuppStruct->AddNode(sideASuppForwCone, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideASuppForwCone, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
  trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  zloc += kSuppBackRingThick1;
  trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
			   new TGeoTranslation(0, 0, zloc) );
  trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));

  xloc = kSuppRearRingXRodHole;
  yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
  zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
  trayASuppStruct->AddNode(sideASuppRod, 1,
			   new TGeoTranslation( xloc, yloc, zloc) );
  trayASuppStruct->AddNode(sideASuppRod, 2,
			   new TGeoTranslation(-xloc, yloc, zloc) );
  trayASuppStruct->AddNode(sideASuppRod, 3,
			   new TGeoTranslation( xloc,-yloc, zloc) );
  trayASuppStruct->AddNode(sideASuppRod, 4,
			   new TGeoTranslation(-xloc,-yloc, zloc) );

  zloc += suppRod->GetDz();
  trayASuppStruct->AddNode(sideASuppRearRing, 1,
			   new TGeoTranslation( 0, 0, zloc) );
  trayASuppStruct->AddNode(sideASuppRearRing, 2,
			   new TGeoCombiTrans( 0, 0, zloc,
					       new TGeoRotation("",180,0,0)));


  // Finally put everything in the mother volume
  moth->AddNode(trayASuppStruct,1,0);

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
						       TGeoManager *mgr){
//
// Creates the all SPD cable trays which are outside the ITS support cones
// but still inside the TPC
// In order to avoid a huge monolithic routine, this method actually
// calls inner methods to create and assemble the various (macro)pieces
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      15 Nov 2009  Mario Sitta
//
// Technical data are taken from AutoCAD drawings and other (oral)
// information given by F.Tosello
//

  SPDCableTraysSideA(moth, mgr);
  SPDCableTraysSideC(moth, mgr);

}

//______________________________________________________________________
void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
						       TGeoManager *mgr){
//
// Creates the all SDD cable trays which are outside the ITS support cones
// but still inside the TPC
// In order to avoid a huge monolithic routine, this method actually
// calls inner methods to create and assemble the various (macro)pieces
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:      14 Dec 2009  Mario Sitta
//

  SDDCableTraysSideA(moth, mgr);
  SDDCableTraysSideC(moth, mgr);

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
						       TGeoManager *mgr){
//
// Creates the SSD cable trays which are outside the ITS support cones
// but still inside the TPC
// In order to avoid a huge monolithic routine, this method actually
// calls inner methods to create and assemble the various (macro)pieces
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:      15 Nov 2009  Mario Sitta
//

  SSDCableTraysSideA(moth, mgr);
  SSDCableTraysSideC(moth, mgr);

  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
					    const TGeoManager *mgr){
//
// Creates the SPD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:      15 Feb 2010  Mario Sitta
// Updated:      10 Jun 2010  Mario Sitta  Freon inside cooling pipes
// Updated:      08 Sep 2010  Mario Sitta
// Updated:      14 Sep 2010  Mario Sitta  Cables prolonged till cone
//
// 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 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
  // (parts of 0872/G/D)
  const Double_t kTrayAR1Trans           =  396.93 *fgkmm;
  const Double_t kTrayAR2Trans           =  413.93 *fgkmm;
  const Double_t kTrayAZTrans            = 1011.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 kForwardTrayWide        =   94.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardTrayFirstHigh   =   83.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardTraySecondHigh  =   52.70 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardTrayTotalLen    =  853.00 *fgkmm;
  const Double_t kForwardTrayFirstLen    =  435.00 *fgkmm;
  const Double_t kForwardTrayWingWide    =   16.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardTrayInterSpace  =   18.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardTrayThick       =    2.00 *fgkmm;

  const Int_t    kForwardSideNpoints     =    6;

  const Double_t kExternalTrayLen        = 1200.00 *fgkmm;
  const Double_t kExternalTrayWide       = kForwardTrayWide;
  const Double_t kExternalTrayHigh       = kForwardTraySecondHigh;
  const Double_t kExternalTrayThick      = kForwardTrayThick;

  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 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.024*fgkmm;// Computed
  const Double_t kCoaxCableHighMeg       =    5.695*fgkmm;// Computed

  const Double_t kTrayCCablesRot         =   75.000*fgkDegree;// Computed
  const Double_t kTrayCCablesZLenOut     =  227.000*fgkmm;// Computed


  // Local variables
  Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
  Double_t xloc, yloc, zloc, alpharot;


  // The two tray components as assemblies
  TGeoVolumeAssembly *cableTrayAForw =
    new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
  TGeoVolumeAssembly *cableTrayAExt =
    new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
  

  // First create all needed shapes

  // The lower face of the forward tray: a BBox
  TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
					     kForwardTrayThick/2,
					     kForwardTrayTotalLen/2);

  // The side face of the forward tray: a Xtru
  TGeoXtru *forwTraySideFace = new TGeoXtru(2);
  forwTraySideFace->SetName("ITSsuppSPDForwTraySide");

  xprof[0] = 0;
  yprof[0] = kForwardTrayThick;
  xprof[1] = kForwardTrayTotalLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
  xprof[3] = kForwardTrayFirstLen;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
  xprof[5] = xprof[0];
  yprof[5] = yprof[4];

  forwTraySideFace->DefinePolygon(6, xprof, yprof);
  forwTraySideFace->DefineSection(0, 0);
  forwTraySideFace->DefineSection(1, kForwardTrayThick);

  // The covers of the forward tray: two BBox's
  TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
					      kForwardTrayThick/2,
					      kForwardTrayFirstLen/2);

  TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
					     kForwardTrayThick/2,
			     (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);

  // Each small wing of the forward tray: a BBox
  TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
			     (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
					kForwardTrayThick/2);

  // The internal plane of the forward tray: a BBox
  TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
					 kForwardTrayThick/2,
					 kForwardTrayTotalLen/2);

  // The internal wall of the forward tray: a BBox
  TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
				 (kForwardTrayInterSpace-kForwardTrayThick)/2,
					kForwardTrayTotalLen/2);

  // Each horizontal face of the external tray: a BBox
  TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
					  kExternalTrayThick/2,
					  kExternalTrayLen/2);

  // Each vertical face of the external tray: a BBox
  TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
					  kExternalTrayHigh/2,
					  kExternalTrayLen/2);

  // The internal wall of the external tray: a BBox
  TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
				 (kForwardTrayInterSpace-kExternalTrayThick)/2,
				       kExternalTrayLen/2);

  // The cooling tube inside the forward tray: a Tube
  Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
		- 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
  Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
  TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);

  // The freon inside the forward tray tubes: a Tube
  TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);

  // The cooling tube inside the external tray: a Ctub
  TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
				       kExternalTrayLen/2, 0, 360,
				       0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
				       0,                0,               1);

  // The freon inside the forward tray tubes: a Tube
  TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
					kExternalTrayLen/2, 0, 360,
					0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
					0,                0,               1);

  // The optical fibers inside the forward tray: a Xtru
  TGeoXtru *optFibsForw = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
  xprof[1] = 0;
  yprof[1] = 0;
  xprof[2] = kForwardTrayTotalLen;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kOpticalFibersSect;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kOpticalFibersSect;

  optFibsForw->DefinePolygon(6, xprof, yprof);
  optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
  optFibsForw->DefineSection(1, kOpticalFibersSect/2);

  // The optical fibers inside the external tray: a Xtru
  TGeoXtru *optFibsExt = new TGeoXtru(2);
  optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");

  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] + kOpticalFibersSect;
  yprof[3] = yprof[2];
  xprof[3] = yprof[2]*TanD(kTrayAZRot);

  optFibsExt->DefinePolygon(4, xprof, yprof);
  optFibsExt->DefineSection(0, 0);
  optFibsExt->DefineSection(1, kOpticalFibersSect);

  // The Low Voltage cables inside the forward tray: two Xtru
  TGeoXtru *lowCablesForwCu = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
  xprof[1] = 0;
  yprof[1] = 0;
  xprof[2] = kForwardTrayTotalLen;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;

  lowCablesForwCu->DefinePolygon(6, xprof, yprof);
  lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
  lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);

  TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);

  xprof[0] = lowCablesForwCu->GetX(5);
  yprof[0] = lowCablesForwCu->GetY(5);
  xprof[1] = lowCablesForwCu->GetX(4);
  yprof[1] = lowCablesForwCu->GetY(4);
  xprof[2] = lowCablesForwCu->GetX(3);
  yprof[2] = lowCablesForwCu->GetY(3);
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;

  lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
  lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
  lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);

  // 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();
  xprof[0] = yprof[0]*TanD(kTrayAZRot);
  xprof[1] = kExternalTrayLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
  yprof[3] = yprof[2];
  xprof[3] = yprof[2]*TanD(kTrayAZRot);

  lowCablesExtCu->DefinePolygon(4, xprof, yprof);
  lowCablesExtCu->DefineSection(0, 0);
  lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*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 Xtru
  TGeoXtru *hiCablesForwCu = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
  xprof[1] = 0;
  yprof[1] = 0;
  xprof[2] = kForwardTrayTotalLen;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;

  hiCablesForwCu->DefinePolygon(6, xprof, yprof);
  hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
  hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);

  TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);

  xprof[0] = hiCablesForwCu->GetX(5);
  yprof[0] = hiCablesForwCu->GetY(5);
  xprof[1] = hiCablesForwCu->GetX(4);
  yprof[1] = hiCablesForwCu->GetY(4);
  xprof[2] = hiCablesForwCu->GetX(3);
  yprof[2] = hiCablesForwCu->GetY(3);
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;

  hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
  hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
  hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);

  // 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 Coaxial cables inside the forward tray: two Xtru
  TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
  coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
  xprof[1] = 0;
  yprof[1] = 0;
  xprof[2] = kForwardTrayTotalLen;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kCoaxCableSectCu/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kCoaxCableSectCu/2;

  coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
  coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
  coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);

  TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
  coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");

  xprof[0] = coaxCablesForwCu->GetX(5);
  yprof[0] = coaxCablesForwCu->GetY(5);
  xprof[1] = coaxCablesForwCu->GetX(4);
  yprof[1] = coaxCablesForwCu->GetY(4);
  xprof[2] = coaxCablesForwCu->GetX(3);
  yprof[2] = coaxCablesForwCu->GetY(3);
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
  xprof[4] = xprof[1];
  yprof[4] = yprof[3];
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kCoaxCableHighMeg/2;

  coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
  coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
  coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);

  // The Coaxial inside the external tray: two Xtru
  TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
  coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");

  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] + 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 *coaxCablesExtMeg = new TGeoXtru(2);
  coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");

  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] + kCoaxCableHighMeg/2;
  yprof[3] = yprof[2];
  xprof[3] = yprof[2]*TanD(kTrayAZRot);

  coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
  coaxCablesExtMeg->DefineSection(0, 0);
  coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
  TGeoMedium *medIn    = mgr->GetMedium("ITS_INOX$");
  TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
  TGeoMedium *medFibs  = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
  TGeoMedium *medCu    = mgr->GetMedium("ITS_COPPER$");
  TGeoMedium *medPUR   = mgr->GetMedium("ITS_POLYURETHANE$");
  TGeoMedium *medMeg   = mgr->GetMedium("ITS_MEGOLON$");

  TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
					    forwTrayLowerFace, medAl);

  forwTrayABase->SetVisibility(kTRUE);
  forwTrayABase->SetLineColor(6); // Purple
  forwTrayABase->SetLineWidth(1);
  forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
  forwTrayABase->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
					    forwTraySideFace, medAl);

  forwTrayASide->SetVisibility(kTRUE);
  forwTrayASide->SetLineColor(6); // Purple
  forwTrayASide->SetLineWidth(1);
  forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
  forwTrayASide->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
						  forwTrayShortCover, medAl);

  forwTrayACoverShort->SetVisibility(kTRUE);
  forwTrayACoverShort->SetLineColor(6); // Purple
  forwTrayACoverShort->SetLineWidth(1);
  forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
  forwTrayACoverShort->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
						 forwTrayLongCover, medAl);

  forwTrayACoverLong->SetVisibility(kTRUE);
  forwTrayACoverLong->SetLineColor(6); // Purple
  forwTrayACoverLong->SetLineWidth(1);
  forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
  forwTrayACoverLong->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
					     forwTrayWing, medAl);

  forwTrayAWing->SetVisibility(kTRUE);
  forwTrayAWing->SetLineColor(6); // Purple
  forwTrayAWing->SetLineWidth(1);
  forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
  forwTrayAWing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
					      forwTrayPlane, medAl);

  forwTrayAPlane->SetVisibility(kTRUE);
  forwTrayAPlane->SetLineColor(6); // Purple
  forwTrayAPlane->SetLineWidth(1);
  forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
  forwTrayAPlane->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
					     forwTrayWall, medAl);

  forwTrayAWall->SetVisibility(kTRUE);
  forwTrayAWall->SetLineColor(6); // Purple
  forwTrayAWall->SetLineWidth(1);
  forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
  forwTrayAWall->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
					       extTrayHorFace, medAl);

  extTrayAHorFace->SetVisibility(kTRUE);
  extTrayAHorFace->SetLineColor(6); // Purple
  extTrayAHorFace->SetLineWidth(1);
  extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
  extTrayAHorFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
					       extTrayVerFace, medAl);

  extTrayAVerFace->SetVisibility(kTRUE);
  extTrayAVerFace->SetLineColor(6); // Purple
  extTrayAVerFace->SetLineWidth(1);
  extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
  extTrayAVerFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
					    extTrayWall, medAl);

  extTrayAWall->SetVisibility(kTRUE);
  extTrayAWall->SetLineColor(6); // Purple
  extTrayAWall->SetLineWidth(1);
  extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
  extTrayAWall->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
					    coolTubeForw, medIn);

  forwCoolTube->SetVisibility(kTRUE);
  forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
  forwCoolTube->SetLineWidth(1);
  forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
  forwCoolTube->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
					     freonTubeForw, medFreon);

  forwCoolFreon->SetVisibility(kTRUE);
  forwCoolFreon->SetLineColor(kBlue); // Blue
  forwCoolFreon->SetLineWidth(1);
  forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
  forwCoolFreon->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
					   coolTubeExt, medIn);

  extCoolTube->SetVisibility(kTRUE);
  extCoolTube->SetLineColor(kGray); // as in GeometrySPD
  extCoolTube->SetLineWidth(1);
  extCoolTube->SetFillColor(extCoolTube->GetLineColor());
  extCoolTube->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
					    freonTubeExt, medFreon);

  extCoolFreon->SetVisibility(kTRUE);
  extCoolFreon->SetLineColor(kBlue); // Blue
  extCoolFreon->SetLineWidth(1);
  extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
  extCoolFreon->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
					   optFibsForw, medFibs);

  forwOptFibs->SetVisibility(kTRUE);
  forwOptFibs->SetLineColor(kOrange); // Orange
  forwOptFibs->SetLineWidth(1);
  forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
  forwOptFibs->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
					  optFibsExt, medFibs);

  extOptFibs->SetVisibility(kTRUE);
  extOptFibs->SetLineColor(kOrange); // Orange
  extOptFibs->SetLineWidth(1);
  extOptFibs->SetFillColor(extOptFibs->GetLineColor());
  extOptFibs->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 *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
					   coaxCablesForwMeg, medMeg);

  forwCoaxMeg->SetVisibility(kTRUE);
  forwCoaxMeg->SetLineColor(kBlack); // Black
  forwCoaxMeg->SetLineWidth(1);
  forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
  forwCoaxMeg->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 *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
					  coaxCablesExtMeg, medMeg);

  extCoaxMeg->SetVisibility(kTRUE);
  extCoaxMeg->SetLineColor(kBlack); // Black
  extCoaxMeg->SetLineWidth(1);
  extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
  extCoaxMeg->SetFillStyle(4000); // 0% transparent


  // Now build up the trays
  yloc = forwTrayLowerFace->GetDY();
  zloc = forwTrayLowerFace->GetDZ();
  cableTrayAForw->AddNode(forwTrayABase, 1,
		      new TGeoTranslation(0, yloc, zloc));

  xloc = kForwardTrayWide/2;
  cableTrayAForw->AddNode(forwTrayASide, 1,
		      new TGeoCombiTrans( xloc, 0, 0,
					 new TGeoRotation("",90,-90,-90)));
  cableTrayAForw->AddNode(forwTrayASide, 2,
		      new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
					 new TGeoRotation("",90,-90,-90)));

  yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
  zloc = forwTrayShortCover->GetDZ();
  cableTrayAForw->AddNode(forwTrayACoverShort, 1,
		      new TGeoTranslation(0, yloc, zloc));

  yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
  zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
  cableTrayAForw->AddNode(forwTrayACoverLong, 1,
		      new TGeoTranslation(0, yloc, zloc));

  xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
  yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
  zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
  cableTrayAForw->AddNode(forwTrayAWing, 1,
		      new TGeoTranslation( xloc, yloc, zloc));
  cableTrayAForw->AddNode(forwTrayAWing, 2,
		      new TGeoTranslation(-xloc, yloc, zloc));

  yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
  zloc = forwTrayPlane->GetDZ();
  cableTrayAForw->AddNode(forwTrayAPlane, 1,
		      new TGeoTranslation(0, yloc, zloc));

  yloc = kForwardTrayThick + forwTrayWall->GetDY();
  zloc = forwTrayWall->GetDZ();
  cableTrayAForw->AddNode(forwTrayAWall, 1,
		      new TGeoTranslation(0, yloc, zloc));

  forwCoolTube->AddNode(forwCoolFreon, 1, 0);

  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
       + coolTubeForw->GetRmax();
  zloc = coolTubeForw->GetDz();
  cableTrayAForw->AddNode(forwCoolTube, 1,
		      new TGeoTranslation(0, yloc, zloc));

  xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
  cableTrayAForw->AddNode(forwOptFibs, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));

  xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
  cableTrayAForw->AddNode(forwLowCabsCu, 1,
		      new TGeoCombiTrans(-xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));
  cableTrayAForw->AddNode(forwLowCabsPUR, 1,
		      new TGeoCombiTrans(-xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));

  xloc = 2*lowCablesForwCu->GetZ(1) +
	 hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
  cableTrayAForw->AddNode(forwHiCabsCu, 1,
		      new TGeoCombiTrans(-xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));
  cableTrayAForw->AddNode(forwHiCabsPUR, 1,
		      new TGeoCombiTrans(-xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));

  xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
	 coolTubeForw->GetRmax();
  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
  cableTrayAForw->AddNode(forwCoaxCu, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));
  cableTrayAForw->AddNode(forwCoaxMeg, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
					 new TGeoRotation("",-90.,90.,90.)));

  // To simplify following placement in MARS, origin is on top
  yloc = -kExternalTrayHigh + kExternalTrayThick/2;
  zloc = kExternalTrayLen/2;
  cableTrayAExt->AddNode(extTrayAHorFace, 1,
		      new TGeoTranslation( 0, yloc, zloc));

  xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
  yloc = -kExternalTrayHigh/2;
  cableTrayAExt->AddNode(extTrayAVerFace, 1,
		      new TGeoTranslation( xloc, yloc, zloc));
  cableTrayAExt->AddNode(extTrayAVerFace, 2,
		      new TGeoTranslation(-xloc, yloc, zloc));

  yloc = -kExternalTrayThick/2;
  cableTrayAExt->AddNode(extTrayAHorFace, 2,
		      new TGeoTranslation( 0, yloc, zloc));

  yloc = -kExternalTrayHigh
       + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
  cableTrayAExt->AddNode(extTrayAHorFace, 3,
		      new TGeoTranslation( 0, yloc, zloc));

  yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
  cableTrayAExt->AddNode(extTrayAWall, 1,
		      new TGeoTranslation( 0, yloc, zloc));

  extCoolTube->AddNode(extCoolFreon, 1, 0);

  yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
       + coolTubeExt->GetRmax();
  zloc = coolTubeExt->GetDz();
  cableTrayAExt->AddNode(extCoolTube, 1,
		      new TGeoTranslation(0, yloc, zloc));

  xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
  cableTrayAExt->AddNode(extOptFibs, 1,
		      new TGeoCombiTrans( xloc, 0, 0,
					 new TGeoRotation("",90,-90,-90)));

  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 = 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(extCoaxMeg, 1,
		      new TGeoCombiTrans( xloc, 0, 0,
					 new TGeoRotation("",90,-90,-90)));


  // Finally put everything in the mother volume
  Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;

  moth->AddNode(cableTrayAForw,1,
		new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
  moth->AddNode(cableTrayAForw,2,
		new TGeoCombiTrans(  0,-kTrayAR1Trans, kTrayAZTrans,
				    new TGeoRotation("",180, 0, 0)));

  yloc = kTrayAR1Trans + kExternalTrayHigh;
  zloc = kTrayAZTrans + kForwardTrayTotalLen;
  moth->AddNode(cableTrayAExt,1,
		new TGeoCombiTrans( 0, yloc, zloc,
				    new TGeoRotation("",  0,-kTrayAZRot, 0)));
  moth->AddNode(cableTrayAExt,2,
		new TGeoCombiTrans( 0,-yloc, zloc,
				    new TGeoRotation("",180,-kTrayAZRot, 0)));

  alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,3,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,3,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,4,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,4,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,5,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,5,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,6,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,6,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,7,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,7,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,8,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,8,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,9,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,9,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayAR2Trans*SinD(alpharot);
  yloc = kTrayAR2Trans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,10,
			    new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,10,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
					    const TGeoManager *mgr){
//
// Creates the SPD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Return:
//
// 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
// Updated:      14 Sep 2010  Mario Sitta  Cables prolonged till cone
// Updated:      20 Dec 2011  Mario Sitta  Composite vol to avoid new overlap
//
// 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
  const Int_t    kNumTraysSideC       =   10;

  const Double_t kTrayCCablesOutRot   =   75.000 *fgkDegree;// Computed
  const Double_t kTrayCCablesZLenOut  =  245.000 *fgkmm;// Computed

  const Double_t kTrayCHalfWide       =    6.350 *fgkcm;
  const Double_t kTrayCLength1        =  172.800 *fgkcm;
  const Double_t kTrayCLength2        =  189.300 *fgkcm;
  const Double_t kTrayCFirstLen       =  435.000 *fgkmm;
  const Double_t kTrayCFirstHigh      =   83.000 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kTrayCSecondHigh     =   52.700 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kTrayCThick          =    0.200 *fgkcm;
  const Double_t kTrayCInterSpace     =   18.000 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kTrayCFoldAngle      =    5.000 *fgkDegree;

  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 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.024 *fgkmm;// Computed
  const Double_t kCoaxCableHighMeg    =    5.695 *fgkmm;// Computed

  const Double_t kCablesYtrans        =    2.500 *fgkmm;// Avoid ovlps

  // Overall position and rotation of the C-Side Cable Trays
  const Double_t kTraySideCRPos       =   45.300 *fgkcm;
  const Double_t kTraySideCZPos       = -102.400 *fgkcm;
  const Double_t kTraySideCAlphaRot[kNumTraysSideC/2]  =
    {    0.0,      41.0,     -41.0,      76.0,      -76.0};
  // From position of the other trays


  // Local variables
  Double_t xprof[8], yprof[8];
  Double_t xloc, yloc, zloc, delta, alpharot;


  // The single C-Side Cable tray as an assembly
  TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");

  // First create all needed shapes

  // The Cable Tray lower face: a Xtru
  TGeoXtru *sideCHorFace = new TGeoXtru(2);
  sideCHorFace->SetName("ITSsuppSPDTraySideCHor");

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kTrayCLength1;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
  yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
  xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
  yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kTrayCThick , xprof[4], yprof[4]);
  xprof[5] = 0.;
  yprof[5] = kTrayCThick;

  delta = kTrayCHalfWide - kTrayCThick;

  sideCHorFace->DefinePolygon(6, xprof, yprof);
  sideCHorFace->DefineSection(0,-delta);
  sideCHorFace->DefineSection(1, delta);

  // The Cable Tray middle face: a Xtru
  // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
  TGeoXtru *sideCMidFace = new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = kTrayCInterSpace + kTrayCThick;
  xprof[1] = kTrayCLength1;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
  yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
  xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
  yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kTrayCThick , xprof[4], yprof[4]);
  xprof[5] = 0.;
  yprof[5] = yprof[0] + kTrayCThick;

  delta = kTrayCHalfWide - kTrayCThick;

  sideCMidFace->DefinePolygon(6, xprof, yprof);
  sideCMidFace->DefineSection(0,-delta);
  sideCMidFace->DefineSection(1, delta);

  // The Cable Tray lower face: a Xtru
  TGeoXtru *sideCSideFace = new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kTrayCLength1;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
  yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
  xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
  yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kTrayCSecondHigh , xprof[4], yprof[4]);
  xprof[5] = kTrayCFirstLen;
  yprof[5] = kTrayCSecondHigh;
  xprof[6] = xprof[5];
  yprof[6] = kTrayCFirstHigh;
  xprof[7] = xprof[0];
  yprof[7] = yprof[6];

  sideCSideFace->DefinePolygon(8, xprof, yprof);
  sideCSideFace->DefineSection(0, 0);
  sideCSideFace->DefineSection(1, kTrayCThick);

  // The short cover: a BBox
  TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
					   kTrayCThick/2,
					   kTrayCHalfWide-kTrayCThick);

  // The long cover: a Xtru
  TGeoXtru *sideCLongCover = new TGeoXtru(2);

  xprof[5] = sideCSideFace->GetX(5);
  yprof[5] = sideCSideFace->GetY(5);
  xprof[4] = sideCSideFace->GetX(4);
  yprof[4] = sideCSideFace->GetY(4);
  xprof[3] = sideCSideFace->GetX(3);
  yprof[3] = sideCSideFace->GetY(3);
  xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
  yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
	     -kTrayCThick , xprof[1], yprof[1]);
  xprof[0] = xprof[5];
  yprof[0] = yprof[5] - kTrayCThick;

  delta = kTrayCHalfWide - kTrayCThick;

  sideCLongCover->DefinePolygon(6, xprof, yprof);
  sideCLongCover->DefineSection(0,-delta);
  sideCLongCover->DefineSection(1, delta);

  // The internal wall: a Xtru
  TGeoXtru *intWall = new TGeoXtru(2);
  intWall->SetName("ITSsuppSPDTraySideCWall");

  xprof[0] = sideCHorFace->GetX(5);
  yprof[0] = sideCHorFace->GetY(5);
  xprof[1] = sideCHorFace->GetX(4);
  yprof[1] = sideCHorFace->GetY(4);
  xprof[2] = sideCHorFace->GetX(3);
  yprof[2] = sideCHorFace->GetY(3);
  xprof[3] = sideCMidFace->GetX(2);
  yprof[3] = sideCMidFace->GetY(2);
  xprof[4] = sideCMidFace->GetX(1);
  yprof[4] = sideCMidFace->GetY(1);
  xprof[5] = sideCMidFace->GetX(0);
  yprof[5] = sideCMidFace->GetY(0);

  intWall->DefinePolygon(6, xprof, yprof);
  intWall->DefineSection(0,-kTrayCThick/2);
  intWall->DefineSection(1, kTrayCThick/2);

  // The horizontal part of the cooling tube inside the tray: a Tube
  delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
  TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);

  // The freon inside the horizontal part of the cooling tube: a Tube
  TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);

  // The inclined part of the cooling tube inside the tray: a Ctub
  Double_t x3, y3, x4, y4;
  x3 = sideCMidFace->GetX(3);
  y3 = sideCMidFace->GetY(3);
  x4 = sideCMidFace->GetX(4);
  y4 = sideCMidFace->GetY(4);
  delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
		       (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))    +
       (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
       (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );

  TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
			       0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
			       0,                     0,                    1);

  // The freon inside the inclined part of the cooling tube: a Ctub
  TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
			       0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
			       0,                     0,                    1);

  // The part of the cooling tube outside the tray: a Ctub
  TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
			0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
			0, 360,
			0,                        0,                      -1,
			0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));

  // The freon inside the part of the cooling tube outside the tray: a Ctub
  TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
			outTube->GetDz(),
			0, 360,
			0,                        0,                      -1,
			0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));

  // The optical fibers inside the tray: a Xtru
  TGeoXtru *optFibs = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
  xprof[1] = sideCMidFace->GetX(5);
  yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
  xprof[2] = sideCMidFace->GetX(4);
  yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
  xprof[3] = sideCMidFace->GetX(3);
  yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
  xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kOpticalFibersSect , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kOpticalFibersSect;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kOpticalFibersSect;

  optFibs->DefinePolygon(8, xprof, yprof);
  optFibs->DefineSection(0, 0);
  optFibs->DefineSection(1, kOpticalFibersSect);

  // The low voltage cables inside the tray: two Xtru
  TGeoXtru *lowCablesCu = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
  xprof[1] = sideCMidFace->GetX(5);
  yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
  xprof[2] = sideCMidFace->GetX(4);
  yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
  xprof[3] = sideCMidFace->GetX(3);
  yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
  xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kLowVoltCableSectCu , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kLowVoltCableSectCu;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kLowVoltCableSectCu;

  lowCablesCu->DefinePolygon(8, xprof, yprof);
  lowCablesCu->DefineSection(0, 0);
  lowCablesCu->DefineSection(1, kLowVoltCableSectCu);

  TGeoXtru *lowCablesPUR = new TGeoXtru(2);

  xprof[0] = lowCablesCu->GetX(7);
  yprof[0] = lowCablesCu->GetY(7);
  xprof[1] = lowCablesCu->GetX(6);
  yprof[1] = lowCablesCu->GetY(6);
  xprof[2] = lowCablesCu->GetX(5);
  yprof[2] = lowCablesCu->GetY(5);
  xprof[3] = lowCablesCu->GetX(4);
  yprof[3] = lowCablesCu->GetY(4);
  xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kLowVoltCableHighPUR , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kLowVoltCableHighPUR;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kLowVoltCableHighPUR;

  lowCablesPUR->DefinePolygon(8, xprof, yprof);
  lowCablesPUR->DefineSection(0, 0);
  lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);

  // The high voltage cables inside the tray: two Xtru
  TGeoXtru *hiCablesCu = new TGeoXtru(2);

  xprof[0] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
  xprof[1] = sideCMidFace->GetX(5);
  yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
  xprof[2] = sideCMidFace->GetX(4);
  yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
  xprof[3] = sideCMidFace->GetX(3);
  yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
  xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kHiVoltCableSectCu , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kHiVoltCableSectCu;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kHiVoltCableSectCu;

  hiCablesCu->DefinePolygon(8, xprof, yprof);
  hiCablesCu->DefineSection(0, 0);
  hiCablesCu->DefineSection(1, kHiVoltCableSectCu);

  TGeoXtru *hiCablesPUR = new TGeoXtru(2);

  xprof[0] = hiCablesCu->GetX(7);
  yprof[0] = hiCablesCu->GetY(7);
  xprof[1] = hiCablesCu->GetX(6);
  yprof[1] = hiCablesCu->GetY(6);
  xprof[2] = hiCablesCu->GetX(5);
  yprof[2] = hiCablesCu->GetY(5);
  xprof[3] = hiCablesCu->GetX(4);
  yprof[3] = hiCablesCu->GetY(4);
  xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kHiVoltCableHighPUR , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kHiVoltCableHighPUR;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kHiVoltCableHighPUR;

  hiCablesPUR->DefinePolygon(8, 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] = -kTrayCCablesZLenOut;
  yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
  xprof[1] = sideCMidFace->GetX(5);
  yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
  xprof[2] = sideCMidFace->GetX(4);
  yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
  xprof[3] = sideCMidFace->GetX(3);
  yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
  xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kCoaxCableSectCu , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kCoaxCableSectCu;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kCoaxCableSectCu;

  coaxCablesCu->DefinePolygon(8, xprof, yprof);
  coaxCablesCu->DefineSection(0, 0);
  coaxCablesCu->DefineSection(1, kCoaxCableSectCu);

  TGeoXtru *coaxCablesMeg = new TGeoXtru(2);

  xprof[0] = coaxCablesCu->GetX(7);
  yprof[0] = coaxCablesCu->GetY(7);
  xprof[1] = coaxCablesCu->GetX(6);
  yprof[1] = coaxCablesCu->GetY(6);
  xprof[2] = coaxCablesCu->GetX(5);
  yprof[2] = coaxCablesCu->GetY(5);
  xprof[3] = coaxCablesCu->GetX(4);
  yprof[3] = coaxCablesCu->GetY(4);
  xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
  yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
  InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
	      kCoaxCableHighMeg , xprof[5], yprof[5]);
  xprof[6] = 0.;
  yprof[6] = yprof[1] + kCoaxCableHighMeg;
  xprof[7] = xprof[0];
  yprof[7] = yprof[0] + kCoaxCableHighMeg;

  coaxCablesMeg->DefinePolygon(8, xprof, yprof);
  coaxCablesMeg->DefineSection(0, 0);
  coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);

  // To avoid a newly discovered overlap,
  // transform the two overlapping volumes into a Composite Shape
  TGeoCompositeShape *trayIntern =
    new TGeoCompositeShape("ITSSPDInternalTrayC",
			   "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");

  // We have all shapes: now create the real volumes
  TGeoMedium *medAl   = mgr->GetMedium("ITS_ALUMINUM$");
  TGeoMedium *medIn   = mgr->GetMedium("ITS_INOX$");
  TGeoMedium *medFr   = mgr->GetMedium("ITS_Freon$");
  TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
  TGeoMedium *medCu   = mgr->GetMedium("ITS_COPPER$");
  TGeoMedium *medPUR  = mgr->GetMedium("ITS_POLYURETHANE$");
  TGeoMedium *medMeg  = mgr->GetMedium("ITS_MEGOLON$");

  TGeoVolume *traySideCIntern  = new TGeoVolume("ITSsuppSPDTraySideCInternal",
						trayIntern, medAl);

  traySideCIntern->SetVisibility(kTRUE);
  traySideCIntern->SetLineColor(6); // Purple
  traySideCIntern->SetLineWidth(1);
  traySideCIntern->SetFillColor(traySideCIntern->GetLineColor());
  traySideCIntern->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCMidFace  = new TGeoVolume("ITSsuppSPDTraySideCMid",
						 sideCMidFace, medAl);

  traySideCMidFace->SetVisibility(kTRUE);
  traySideCMidFace->SetLineColor(6); // Purple
  traySideCMidFace->SetLineWidth(1);
  traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
  traySideCMidFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCSideFace  = new TGeoVolume("ITSsuppSPDTraySideCSide",
						  sideCSideFace, medAl);

  traySideCSideFace->SetVisibility(kTRUE);
  traySideCSideFace->SetLineColor(6); // Purple
  traySideCSideFace->SetLineWidth(1);
  traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
  traySideCSideFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCShortCover  = new TGeoVolume("ITSsuppSPDTraySideCShCov",
						    sideCShortCover, medAl);

  traySideCShortCover->SetVisibility(kTRUE);
  traySideCShortCover->SetLineColor(6); // Purple
  traySideCShortCover->SetLineWidth(1);
  traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
  traySideCShortCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLongCover  = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
						   sideCLongCover, medAl);

  traySideCLongCover->SetVisibility(kTRUE);
  traySideCLongCover->SetLineColor(6); // Purple
  traySideCLongCover->SetLineWidth(1);
  traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
  traySideCLongCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
						horTube, medIn);

  traySideCHorTube->SetVisibility(kTRUE);
  traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
  traySideCHorTube->SetLineWidth(1);
  traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
  traySideCHorTube->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
						 horFreon, medFr);

  traySideCHorFreon->SetVisibility(kTRUE);
  traySideCHorFreon->SetLineColor(kBlue); // Blue
  traySideCHorFreon->SetLineWidth(1);
  traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
  traySideCHorFreon->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
						incTube, medIn);

  traySideCIncTube->SetVisibility(kTRUE);
  traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
  traySideCIncTube->SetLineWidth(1);
  traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
  traySideCIncTube->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
						 incFreon, medFr);

  traySideCIncFreon->SetVisibility(kTRUE);
  traySideCIncFreon->SetLineColor(kBlue); // Blue
  traySideCIncFreon->SetLineWidth(1);
  traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
  traySideCIncFreon->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
						outTube, medIn);

  traySideCOutTube->SetVisibility(kTRUE);
  traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
  traySideCOutTube->SetLineWidth(1);
  traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
  traySideCOutTube->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
						 outFreon, medFr);

  traySideCOutFreon->SetVisibility(kTRUE);
  traySideCOutFreon->SetLineColor(kBlue); // Blue
  traySideCOutFreon->SetLineWidth(1);
  traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
  traySideCOutFreon->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
						optFibs, medFibs);

  traySideCOptFibs->SetVisibility(kTRUE);
  traySideCOptFibs->SetLineColor(kOrange); // Orange
  traySideCOptFibs->SetLineWidth(1);
  traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
  traySideCOptFibs->SetFillStyle(4000); // 0% transparent

  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);

  traySideCHiCabsCu->SetVisibility(kTRUE);
  traySideCHiCabsCu->SetLineColor(kRed); // Red
  traySideCHiCabsCu->SetLineWidth(1);
  traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
  traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
						  hiCablesPUR, medPUR);

  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 *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
						coaxCablesMeg, medMeg);

  traySideCCoaxMeg->SetVisibility(kTRUE);
  traySideCCoaxMeg->SetLineColor(kBlack); // Black
  traySideCCoaxMeg->SetLineWidth(1);
  traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
  traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent


  // Now build up the trays
  cableTrayC->AddNode(traySideCIntern,1,0);

  cableTrayC->AddNode(traySideCMidFace,1,0);

  zloc = kTrayCHalfWide - kTrayCThick;
  cableTrayC->AddNode(traySideCSideFace, 1,
		      new TGeoTranslation( 0, 0, zloc));
  zloc = -kTrayCHalfWide;
  cableTrayC->AddNode(traySideCSideFace, 2,
		      new TGeoTranslation( 0, 0, zloc));

  xloc = sideCShortCover->GetDX();
  yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
  cableTrayC->AddNode(traySideCShortCover, 1,
		      new TGeoTranslation( xloc, yloc, 0));

  cableTrayC->AddNode(traySideCLongCover,1,0);

  traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
  traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
  traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);

  xloc = horTube->GetDz();
  yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
  cableTrayC->AddNode(traySideCHorTube, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
		      new TGeoRotation("",-90.,-90.,90.)));

  xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
  yloc = sideCMidFace->GetY(4) +  incTube->GetRmax() +
	    (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
  cableTrayC->AddNode(traySideCIncTube, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
		      new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));

  xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
  yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
	 2*outTube->GetRmax();
  cableTrayC->AddNode(traySideCOutTube, 1,
		      new TGeoCombiTrans( xloc, yloc, 0,
		      new TGeoRotation("",-70.,-90.,90.)));

  zloc = horTube->GetRmax();
  cableTrayC->AddNode(traySideCOptFibs, 1,
		      new TGeoTranslation( 0, 0, zloc));

  zloc = kLowVoltCableSectCu + horTube->GetRmax();
  cableTrayC->AddNode(traySideCLowCabsCu, 1,
		      new TGeoTranslation( 0, 0,-zloc));
  cableTrayC->AddNode(traySideCLowCabsPUR, 1,
		      new TGeoTranslation( 0, 0,-zloc));

  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(traySideCCoaxMeg, 1,
		      new TGeoTranslation( 0, 0, zloc));


  // Finally put everything in the mother volume
  for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
    alpharot = kTraySideCAlphaRot[jt];

    xloc = kTraySideCRPos*SinD(alpharot);
    yloc = kTraySideCRPos*CosD(alpharot);
    moth->AddNode(cableTrayC,2*jt+1,
		new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
		new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
    alpharot += 180;
    xloc = kTraySideCRPos*SinD(alpharot);
    yloc = kTraySideCRPos*CosD(alpharot);
    moth->AddNode(cableTrayC,2*jt+2,
		new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
		new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
  }


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
					     const TGeoManager *mgr){
//
// Creates the SDD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// 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
//

  // Overall position and rotation of the A-Side Cable Trays
  // (parts of 0872/G/D)
  const Double_t kTrayARTrans            =  408.35 *fgkmm;
  const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
  const Double_t kTrayAZToSupportRing    =  435.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
  const Double_t kForwardCoverLength     =  380.00 *fgkmm;
  const Double_t kForwardCoverWide       =  133.00 *fgkmm;
  const Double_t kForwardCoverHeight     =   10.00 *fgkmm;
  const Double_t kForwardCoverThick      =    1.00 *fgkmm;

  const Double_t kExternTrayTotalLen     = 1200.00 *fgkmm;
  const Double_t kExternTrayTotalHeight  =   52.00 *fgkmm;
  const Double_t kExternCoverLen         = kExternTrayTotalLen;
  const Double_t kExternCoverThick       =    5.00 *fgkmm;
  const Double_t kExternCoverSideThick   =    3.00 *fgkmm;

  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, height;


  // The whole tray as an assembly
  TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
  

  // First create all needed shapes

  // The forward tray is very complex and deserves a dedicated method
  CreateSDDForwardTraySideA(cableTrayA,mgr);

  // The forward cover: a Xtru
  TGeoXtru *forwardCover = new TGeoXtru(2);
  forwardCover->SetName("ITSsuppSDDForwCover");

  xprof[0] = kForwardCoverWide/2;
  yprof[0] = kForwardCoverHeight;
  xprof[1] = xprof[0];
  yprof[1] = 0;
  xprof[2] = xprof[1] - kForwardCoverThick;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[0] - kForwardCoverThick;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 4; jp++) {
    xprof[4+jp] = -xprof[3-jp];
    yprof[4+jp] =  yprof[3-jp];
  }

  forwardCover->DefinePolygon(8, xprof, yprof);
  forwardCover->DefineSection(0, 0);
  forwardCover->DefineSection(1, kForwardCoverLength);

  // The external tray (as 0872/G/D/03): a Xtru
  TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
						  kExternTrayTotalHeight);

  // 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 *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);

  forwardTrayCover->SetVisibility(kTRUE);
  forwardTrayCover->SetLineColor(kMagenta+1); // Purple
  forwardTrayCover->SetLineWidth(1);
  forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
  forwardTrayCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
					       externalTray, medAl);

  externalTraySDD->SetVisibility(kTRUE);
  externalTraySDD->SetLineColor(6); // Purple
  externalTraySDD->SetLineWidth(1);
  externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
  externalTraySDD->SetFillStyle(4000); // 0% transparent

  TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
					       externCover, medAntic);

  externTrayCover->SetVisibility(kTRUE);
  externTrayCover->SetLineColor(kMagenta+1); // Purple
  externTrayCover->SetLineWidth(1);
  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);
  zloc = kForwardTrayUpperLength - kForwardCoverLength;
  cableTrayA->AddNode(forwardTrayCover, 1,
		      new TGeoTranslation( 0, yloc, zloc) );

  Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
		   - kExternCoverYTrans;

  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 = 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) );

  yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
  cableTrayA->AddNode(steelCoolManif, 1,
		      new TGeoTranslation( 0, yloc, zloc) );

  yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
  cableTrayA->AddNode(waterCoolManif, 1,
		      new TGeoTranslation( 0, yloc, zloc) );

  yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
  cableTrayA->AddNode(alCoolManif, 1,
		      new TGeoTranslation( 0, yloc, zloc) );

  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)        ) );

  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;

  alpharot = -kTrayAFirstRotAng;
  xloc = rforw*SinD(alpharot);
  yloc = rforw*CosD(alpharot);
  zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;

  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(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(cableTrayA,3,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );

  alpharot += 180;
  xloc = rforw*SinD(alpharot);
  yloc = rforw*CosD(alpharot);
  moth->AddNode(cableTrayA,4,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
					    const TGeoManager *mgr){
//
// Creates the SDD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      17 Apr 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings and other (oral)
// information given by F.Tosello
//

  // 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.50    *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;
  const Double_t kTraySideCAlphaRot[kNumTraySideC]  = {    -23.0,      59.0,
    /* from SSD tray position */		       180.-23.0, 180.+59.0};


  // Local variables
  Double_t xprof[6], yprof[6];
  Double_t height, xloc, yloc, zloc, alpharot, alphafold;


  // The assembly holding the metallic structure
  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 *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;

  for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
    alpharot = kTraySideCAlphaRot[jt];
    xloc = kTraySideCRPos*SinD(alpharot);
    yloc = kTraySideCRPos*CosD(alpharot);
    moth->AddNode(trayStructure,jt+1,
		       new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
		       new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
  }


  return;
}


//______________________________________________________________________
void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
					    const TGeoManager *mgr){
//
// Creates the SSD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      30 Dec 2009  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello and
// Ton van den Brink
// Cables and cooling tubes are approximated with proper materials and
// rectangular cross sections, always preserving the total material budget.
//

  // Dimensions and positions of the A-Side Cable Trays
  // (parts of 0872/G/D)
  const Double_t kTrayARTrans            =  408.35 *fgkmm;
  const Double_t kTrayAZTrans            = 1011.00 *fgkmm;
  const Double_t kForwardSideYTrans      =   12.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kCoversYTrans           =    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 kTrayTotalHeight        =   52.00 *fgkmm;
  const Double_t kTrayHeighToBend        =   32.00 *fgkmm;
  const Double_t kTrayWidth              =  130.00 *fgkmm;
  const Double_t kTrayThick              =    2.00 *fgkmm;

  const Double_t kTrayBendAngle          =   22.00 *TMath::DegToRad();

  const Double_t kForwardTrayTotalLen    =  853.00 *fgkmm;
  const Double_t kForwardTrayFirstLen    =  350.00 *fgkmm;
  const Double_t kForwardTrayFirstHeight =   47.00 *fgkmm;
  const Double_t kForwardCoverLen        =  420.00 *fgkmm;

  const Double_t kForwardSideLength      = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
  const Double_t kForwardSideHeight      =   90.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardSideThick       =    1.00 *fgkmm;//!!!TO BE CHECKED!!!
  const Double_t kForwardCoverHeight     =   10.00 *fgkmm;//!!!TO BE CHECKED!!!

  const Double_t kExternalTrayTotalLen   = 1200.00 *fgkmm;
  const Double_t kExternalCoverLen       = kExternalTrayTotalLen;
  const Double_t kExternalCoverThick     =    5.00 *fgkmm;

  const Int_t    kForwardTrayNpoints     =   16;

  const Double_t kServicesWidth          =  100.00 *fgkmm;
  const Double_t kCopperHeight           =   11.20 *fgkmm;// 1120 mm^2
  const Double_t kCablePlasticHeight     =   11.50 *fgkmm;// 1150 mm^2
  const Double_t kCoolingWaterHeight     =    2.65 *fgkmm;//  265 mm^2
  const Double_t kPoliUrethaneHeight     =    4.62 *fgkmm;//  462 mm^2


  // Local variables
  Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
  Double_t xloc, yloc, zloc, alpharot, totalhi;


  // The two tray components as assemblies
  TGeoVolumeAssembly *cableTrayAForw =
    new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
  TGeoVolumeAssembly *cableTrayAExt =
    new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
  

  // First create all needed shapes

  // The first part of the forward tray (part of 0872/G/D/07): a Xtru
  TGeoXtru *forwTrayPart1 = new TGeoXtru(2);

  xprof[3] = kTrayWidth/2;
  yprof[3] = kForwardTrayFirstHeight;
  xprof[2] = xprof[3] - kTrayThick;
  yprof[2] = yprof[3];
  xprof[4] = xprof[3];
  yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
  xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
  yprof[5] = 0;

  InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
	      -kTrayThick, xprof[1], yprof[1]);

  xprof[6] = -xprof[5];
  yprof[6] =  yprof[5];

  InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
	      -kTrayThick, xprof[0], yprof[0]);

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 6; jp++) {
    xprof[6+jp] = -xprof[5-jp];
    yprof[6+jp] =  yprof[5-jp];
  }

  // And now the actual Xtru
  forwTrayPart1->DefinePolygon(12, xprof, yprof);
  forwTrayPart1->DefineSection(0, 0);
  forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);

  // The second part of the forward tray (part of 0872/G/D/07): a Xtru
  TGeoXtru *forwTrayPart2 =
    CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
			   kTrayTotalHeight);

  // The external tray (as 0872/G/D/03): a Xtru with same profile
  TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
						  kTrayTotalHeight);

  // The side wall of the forward tray: a BBox
  TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
				    kForwardSideHeight/2,
				    kForwardSideLength/2);

  // The side cover over the walls: a Xtru
  TGeoXtru *forwSideCover = new TGeoXtru(2);
  forwSideCover->SetName("ITSsuppSSDForwCover");

  xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
  yprof[0] = kForwardCoverHeight;
  xprof[1] = xprof[0];
  yprof[1] = 0;
  xprof[2] = xprof[1] - kForwardSideThick;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[0] - kForwardSideThick;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 4; jp++) {
    xprof[4+jp] = -xprof[3-jp];
    yprof[4+jp] =  yprof[3-jp];
  }

  forwSideCover->DefinePolygon(8, xprof, yprof);
  forwSideCover->DefineSection(0, 0);
  forwSideCover->DefineSection(1, kForwardSideLength);

  // The forward and external covers: two Composite Shape's
  TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);

  TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);

  // The cable copper inside the forward tray: a BBox
  TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
				      kCopperHeight/2,
				      kForwardTrayTotalLen/2);

  // The cable copper inside the forward tray: a Xtru
  TGeoXtru *extCopper = new TGeoXtru(2);
  extCopper->SetName("ITSsuppSSDExtTrayCopper");

  totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
	  - kTrayThick;

  xprof[0] = -totalhi*TanD(kTrayAZRot);
  yprof[0] = kTrayThick;
  xprof[1] = kExternalTrayTotalLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kCopperHeight;
  totalhi -= kCopperHeight;
  xprof[3] = -totalhi*TanD(kTrayAZRot);
  yprof[3] = yprof[2];

  extCopper->DefinePolygon(4, xprof, yprof);
  extCopper->DefineSection(0, 0);
  extCopper->DefineSection(1, kServicesWidth);

  // The cable plastic inside the forward tray: a BBox
  TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
				       kCablePlasticHeight/2,
				       kForwardTrayTotalLen/2);

  // The cable plastic inside the forward tray: a Xtru
  TGeoXtru *extPlastic = new TGeoXtru(2);
  extPlastic->SetName("ITSsuppSSDExtTrayPlastic");

  totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
	  - kTrayThick - kCopperHeight;

  xprof[0] = -totalhi*TanD(kTrayAZRot);
  yprof[0] = kTrayThick;
  xprof[1] = kExternalTrayTotalLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kCablePlasticHeight;
  totalhi -= kCablePlasticHeight;
  xprof[3] = -totalhi*TanD(kTrayAZRot);
  yprof[3] = yprof[2];

  extPlastic->DefinePolygon(4, xprof, yprof);
  extPlastic->DefineSection(0, 0);
  extPlastic->DefineSection(1, kServicesWidth);

  // The cooling water inside the forward tray: a BBox
  TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
				     kCoolingWaterHeight/2,
				     kForwardTrayTotalLen/2);

  // The cooling water inside the forward tray: a Xtru
  TGeoXtru *extWater = new TGeoXtru(2);
  extWater->SetName("ITSsuppSSDExtTrayWater");

  totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
	  - kTrayThick - kCopperHeight - kCablePlasticHeight;

  xprof[0] = -totalhi*TanD(kTrayAZRot);
  yprof[0] = kTrayThick;
  xprof[1] = kExternalTrayTotalLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kCoolingWaterHeight;
  totalhi -= kCoolingWaterHeight;
  xprof[3] = -totalhi*TanD(kTrayAZRot);
  yprof[3] = yprof[2];

  extWater->DefinePolygon(4, xprof, yprof);
  extWater->DefineSection(0, 0);
  extWater->DefineSection(1, kServicesWidth);

  // The polyurethane inside the forward tray: a BBox
  TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
				   kPoliUrethaneHeight/2,
				   kForwardTrayTotalLen/2);

  // The poliurethane inside the forward tray: a Xtru
  TGeoXtru *extPUR = new TGeoXtru(2);
  extPUR->SetName("ITSsuppSSDExtTrayPUR");

  totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
	  - kTrayThick - kCopperHeight - kCablePlasticHeight
	  - kCoolingWaterHeight;

  xprof[0] = -totalhi*TanD(kTrayAZRot);
  yprof[0] = kTrayThick;
  xprof[1] = kExternalTrayTotalLen;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kPoliUrethaneHeight;
  totalhi -= kPoliUrethaneHeight;
  xprof[3] = -totalhi*TanD(kTrayAZRot);
  yprof[3] = yprof[2];

  extPUR->DefinePolygon(4, xprof, yprof);
  extPUR->DefineSection(0, 0);
  extPUR->DefineSection(1, kServicesWidth);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
  TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
  TGeoMedium *medCu    = mgr->GetMedium("ITS_COPPER$");
  TGeoMedium *medFEP   = mgr->GetMedium("ITS_SSD FEP$");
  TGeoMedium *medH2O   = mgr->GetMedium("ITS_WATER$");
  TGeoMedium *medPUR   = mgr->GetMedium("ITS_POLYURETHANE$");

  TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
					     forwTrayPart1, medAl);

  forwTrayFirst->SetVisibility(kTRUE);
  forwTrayFirst->SetLineColor(6); // Purple
  forwTrayFirst->SetLineWidth(1);
  forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
  forwTrayFirst->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
					      forwTrayPart2, medAl);

  forwTraySecond->SetVisibility(kTRUE);
  forwTraySecond->SetLineColor(6); // Purple
  forwTraySecond->SetLineWidth(1);
  forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
  forwTraySecond->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
					    forwSide, medAl);

  forwTraySide->SetVisibility(kTRUE);
  forwTraySide->SetLineColor(6); // Purple
  forwTraySide->SetLineWidth(1);
  forwTraySide->SetFillColor(forwTraySide->GetLineColor());
  forwTraySide->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
					    forwSideCover, medAl);

  forwTraySideCover->SetVisibility(kTRUE);
  forwTraySideCover->SetLineColor(6); // Purple
  forwTraySideCover->SetLineWidth(1);
  forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
  forwTraySideCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
					       externalTray, medAl);

  externalTraySSD->SetVisibility(kTRUE);
  externalTraySSD->SetLineColor(6); // Purple
  externalTraySSD->SetLineWidth(1);
  externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
  externalTraySSD->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
						forwardCover, medAntic);

  forwardTrayCover->SetVisibility(kTRUE);
  forwardTrayCover->SetLineColor(kMagenta+1); // Purple
  forwardTrayCover->SetLineWidth(1);
  forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
  forwardTrayCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
					       externCover, medAntic);

  externTrayCover->SetVisibility(kTRUE);
  externTrayCover->SetLineColor(kMagenta+1); // Purple
  externTrayCover->SetLineWidth(1);
  externTrayCover->SetFillColor(externTrayCover->GetLineColor());
  externTrayCover->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
					   forwCopper, medCu);

  forwCableCu->SetVisibility(kTRUE);
  forwCableCu->SetLineColor(kRed); // Red
  forwCableCu->SetLineWidth(1);
  forwCableCu->SetFillColor(forwCableCu->GetLineColor());
  forwCableCu->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
					  extCopper, medCu);

  extCableCu->SetVisibility(kTRUE);
  extCableCu->SetLineColor(kRed); // Red
  extCableCu->SetLineWidth(1);
  extCableCu->SetFillColor(extCableCu->GetLineColor());
  extCableCu->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
					    forwPlastic, medFEP);

  forwCableFEP->SetVisibility(kTRUE);
  forwCableFEP->SetLineColor(kYellow); // Yellow
  forwCableFEP->SetLineWidth(1);
  forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
  forwCableFEP->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
					   extPlastic, medFEP);

  extCableFEP->SetVisibility(kTRUE);
  extCableFEP->SetLineColor(kYellow); // Yellow
  extCableFEP->SetLineWidth(1);
  extCableFEP->SetFillColor(extCableFEP->GetLineColor());
  extCableFEP->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
					     forwWater, medH2O);

  forwTrayWater->SetVisibility(kTRUE);
  forwTrayWater->SetLineColor(kBlue); // Blue
  forwTrayWater->SetLineWidth(1);
  forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
  forwTrayWater->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
					    extWater, medH2O);

  extTrayWater->SetVisibility(kTRUE);
  extTrayWater->SetLineColor(kBlue); // Blue
  extTrayWater->SetLineWidth(1);
  extTrayWater->SetFillColor(extTrayWater->GetLineColor());
  extTrayWater->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
					  forwPUR, medPUR);

  forwPolyUr->SetVisibility(kTRUE);
  forwPolyUr->SetLineColor(kGray); // Gray
  forwPolyUr->SetLineWidth(1);
  forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
  forwPolyUr->SetFillStyle(4000); // 0% transparent

  TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
					 extPUR, medPUR);

  extPolyUr->SetVisibility(kTRUE);
  extPolyUr->SetLineColor(kGray); // Gray
  extPolyUr->SetLineWidth(1);
  extPolyUr->SetFillColor(extPolyUr->GetLineColor());
  extPolyUr->SetFillStyle(4000); // 0% transparent


  // Now build up the tray
  cableTrayAForw->AddNode(forwTrayFirst, 1, 0);

  cableTrayAForw->AddNode(forwTraySecond, 1,
			new TGeoTranslation(0, 0, kForwardTrayFirstLen) );

  xloc = kTrayWidth/2 + kForwardSideThick/2;
  yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
  zloc = kForwardSideLength/2;
  cableTrayAForw->AddNode(forwTraySide,1,
			new TGeoTranslation( xloc, yloc, zloc) );
  cableTrayAForw->AddNode(forwTraySide,2,
			new TGeoTranslation(-xloc, yloc, zloc) );

  yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
       - kForwardCoverHeight;
  cableTrayAForw->AddNode(forwTraySideCover,1,
			new TGeoTranslation(0, yloc, 0) );

  yloc = kTrayTotalHeight - kCoversYTrans;
  zloc = kForwardTrayTotalLen - kForwardCoverLen;
  cableTrayAForw->AddNode(forwardTrayCover,1,
			new TGeoTranslation(0, yloc, zloc) );

  yloc = kTrayThick + forwCopper->GetDY();
  zloc = forwCopper->GetDZ();
  cableTrayAForw->AddNode(forwCableCu, 1,
			new TGeoTranslation(0, yloc, zloc) );

  yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
  zloc = forwPlastic->GetDZ();
  cableTrayAForw->AddNode(forwCableFEP, 1,
			new TGeoTranslation(0, yloc, zloc) );

  yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
  zloc = forwWater->GetDZ();
  cableTrayAForw->AddNode(forwTrayWater, 1,
			new TGeoTranslation(0, yloc, zloc) );

  yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
       + kCoolingWaterHeight + forwPUR->GetDY();
  zloc = forwPUR->GetDZ();
  cableTrayAForw->AddNode(forwPolyUr, 1,
			new TGeoTranslation(0, yloc, zloc) );

  // To simplify following placement in MARS, origin is on top
  totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;

  yloc = -totalhi;
  cableTrayAExt->AddNode(externalTraySSD, 1,
			new TGeoTranslation(0, yloc, 0) );

  yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
  cableTrayAExt->AddNode(externTrayCover,1,
			new TGeoTranslation(0, yloc, 0) );

  xloc = extCopper->GetDZ();
  yloc = -totalhi;
  cableTrayAExt->AddNode(extCableCu,1,
		        new TGeoCombiTrans( xloc, yloc, 0,
		        new TGeoRotation("",-90, 90, 90)        ) );

  xloc = extPlastic->GetDZ();
  yloc = -totalhi + kCopperHeight;
  cableTrayAExt->AddNode(extCableFEP,1,
		        new TGeoCombiTrans( xloc, yloc, 0,
		        new TGeoRotation("",-90, 90, 90)        ) );

  xloc = extWater->GetDZ();
  yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
  cableTrayAExt->AddNode(extTrayWater,1,
		        new TGeoCombiTrans( xloc, yloc, 0,
		        new TGeoRotation("",-90, 90, 90)        ) );

  xloc = extPUR->GetDZ();
  yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
  cableTrayAExt->AddNode(extPolyUr,1,
		        new TGeoCombiTrans( xloc, yloc, 0,
		        new TGeoRotation("",-90, 90, 90)        ) );


  // Finally put everything in the mother volume
  zloc = kTrayAZTrans;
  Double_t zlocext = zloc + kForwardTrayTotalLen;
  Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;

  alpharot = kTrayAFirstRotAng;
  xloc = kTrayARTrans*SinD(alpharot);
  yloc = kTrayARTrans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,1,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,1,
			    new TGeoCombiTrans( xloc, yloc, zlocext,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayARTrans*SinD(alpharot);
  yloc = kTrayARTrans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,2,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,2,
			    new TGeoCombiTrans( xloc, yloc, zlocext,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
  xloc = kTrayARTrans*SinD(alpharot);
  yloc = kTrayARTrans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,3,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,3,
			    new TGeoCombiTrans( xloc, yloc, zlocext,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );

  alpharot += 180;
  xloc = kTrayARTrans*SinD(alpharot);
  yloc = kTrayARTrans*CosD(alpharot);
  moth->AddNode(cableTrayAForw,4,
			    new TGeoCombiTrans( xloc, yloc, zloc,
			    new TGeoRotation("",-alpharot,0,0)   )   );
  xloc = rExtTray*SinD(alpharot);
  yloc = rExtTray*CosD(alpharot);
  moth->AddNode(cableTrayAExt,4,
			    new TGeoCombiTrans( xloc, yloc, zlocext,
			    new TGeoRotation("",-alpharot,-kTrayAZRot,0)  )  );


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
					    const TGeoManager *mgr){
//
// Creates the SSD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
// (part of this code is taken or anyway inspired to ServicesCableSupport
// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Created:         ???       Bjorn S. Nilsen
// Updated:      15 Apr 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings and other (oral)
// information given by F.Tosello
//

  // Dimensions and positions of the C-Side Cable Tray elements
  const Int_t    kNumTraySideC           =    4;

  const Double_t kSideCFoldAngle         =    5.00 *fgkDegree;

  const Double_t kServicesWidth          =  100.00 *fgkmm;
  const Double_t kCopperHeight           =   11.20 *fgkmm;// 1120 mm^2
  const Double_t kCablePlasticHeight     =   11.50 *fgkmm;// 1150 mm^2
  const Double_t kCoolingWaterHeight     =    2.65 *fgkmm;//  265 mm^2
  const Double_t kPoliUrethaneHeight     =    4.62 *fgkmm;//  462 mm^2
  const Double_t kCablesYtrans           =    2.50 *fgkmm;// Avoid ovlps

  // Overall position and rotation of the C-Side Cable Trays
  const Double_t kTraySideCRPos          =   45.30    *fgkcm;
  const Double_t kTraySideCZPos          = -102.40    *fgkcm;
  const Double_t kTraySideCAlphaRot[kNumTraySideC]  = {     23.0,     -59.0,
    /* from Patch panel position */		       180.+23.0, 180.-59.0};


  // Local variables
  Double_t xprof[6], yprof[6];
  Double_t xloc, yloc, alpharot, alphafold;


  // The assembly holding the metallic structure
  TGeoVolumeAssembly *trayStructure =
				CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");

  // The cable copper inside the tray: a Xtru
  TGeoXtru *copper = new TGeoXtru(2);
  copper->SetName("ITSsuppSSDTrayCCopper");

  // Copper lies on the lower plate: get position of its points
  TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
  xprof[0] = lowerplate->GetX(5);
  yprof[0] = lowerplate->GetY(5) + kCablesYtrans;
  xprof[1] = lowerplate->GetX(4);
  yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
  xprof[2] = lowerplate->GetX(3);
  yprof[2] = lowerplate->GetY(3) + kCablesYtrans;
  xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
  yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kCopperHeight , xprof[4], yprof[4]);
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kCopperHeight;

  copper->DefinePolygon(6, xprof, yprof);
  copper->DefineSection(0, -kServicesWidth/2);
  copper->DefineSection(1,  kServicesWidth/2);

  // The cable plastic inside the tray: a Xtru
  TGeoXtru *plastic = new TGeoXtru(2);
  plastic->SetName("ITSsuppSSDTrayCPlastic");

  xprof[0] = copper->GetX(5);
  yprof[0] = copper->GetY(5);
  xprof[1] = copper->GetX(4);
  yprof[1] = copper->GetY(4);
  xprof[2] = copper->GetX(3);
  yprof[2] = copper->GetY(3);
  xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
  yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kCablePlasticHeight , xprof[4], yprof[4]);
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kCablePlasticHeight;

  plastic->DefinePolygon(6, xprof, yprof);
  plastic->DefineSection(0, -kServicesWidth/2);
  plastic->DefineSection(1,  kServicesWidth/2);

  // The cooling water inside the tray: a Xtru
  TGeoXtru *water = new TGeoXtru(2);
  water->SetName("ITSsuppSSDTrayCWater");

  xprof[0] = plastic->GetX(5);
  yprof[0] = plastic->GetY(5);
  xprof[1] = plastic->GetX(4);
  yprof[1] = plastic->GetY(4);
  xprof[2] = plastic->GetX(3);
  yprof[2] = plastic->GetY(3);
  xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
  yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kCoolingWaterHeight , xprof[4], yprof[4]);
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kCoolingWaterHeight;

  water->DefinePolygon(6, xprof, yprof);
  water->DefineSection(0, -kServicesWidth/2);
  water->DefineSection(1,  kServicesWidth/2);

  // The poliurethane inside the tray: a Xtru
  TGeoXtru *pur = new TGeoXtru(2);
  pur->SetName("ITSsuppSSDTrayCPUR");
  xprof[0] = water->GetX(5);
  yprof[0] = water->GetY(5);
  xprof[1] = water->GetX(4);
  yprof[1] = water->GetY(4);
  xprof[2] = water->GetX(3);
  yprof[2] = water->GetY(3);
  xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
  yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kPoliUrethaneHeight , xprof[4], yprof[4]);
  xprof[5] = xprof[0];
  yprof[5] = yprof[0] + kPoliUrethaneHeight;

  pur->DefinePolygon(6, xprof, yprof);
  pur->DefineSection(0, -kServicesWidth/2);
  pur->DefineSection(1,  kServicesWidth/2);


  // We have all shapes: now create the real volumes
  TGeoMedium *medCu    = mgr->GetMedium("ITS_COPPER$");
  TGeoMedium *medFEP   = mgr->GetMedium("ITS_SSD FEP$");
  TGeoMedium *medH2O   = mgr->GetMedium("ITS_WATER$");
  TGeoMedium *medPUR   = mgr->GetMedium("ITS_POLYURETHANE$");

  TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
					   copper, medCu);

  copperCable->SetVisibility(kTRUE);
  copperCable->SetLineColor(kRed); // Red
  copperCable->SetLineWidth(1);
  copperCable->SetFillColor(copperCable->GetLineColor());
  copperCable->SetFillStyle(4000); // 0% transparent

  TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
					plastic, medFEP);

  cableFEP->SetVisibility(kTRUE);
  cableFEP->SetLineColor(kYellow); // Yellow
  cableFEP->SetLineWidth(1);
  cableFEP->SetFillColor(cableFEP->GetLineColor());
  cableFEP->SetFillStyle(4000); // 0% transparent

  TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
					 water, medH2O);

  trayWater->SetVisibility(kTRUE);
  trayWater->SetLineColor(kBlue); // Blue
  trayWater->SetLineWidth(1);
  trayWater->SetFillColor(trayWater->GetLineColor());
  trayWater->SetFillStyle(4000); // 0% transparent

  TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
					  pur, medPUR);

  trayPolyUr->SetVisibility(kTRUE);
  trayPolyUr->SetLineColor(kGray); // Gray
  trayPolyUr->SetLineWidth(1);
  trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
  trayPolyUr->SetFillStyle(4000); // 0% transparent


  // Now fill in the tray
  trayStructure->AddNode(copperCable,1,0);
  trayStructure->AddNode(cableFEP,1,0);
  trayStructure->AddNode(trayWater,1,0);
  trayStructure->AddNode(trayPolyUr,1,0);


  // Finally put everything in the mother volume
  alphafold = kSideCFoldAngle;

  for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
    alpharot = kTraySideCAlphaRot[jt];
    xloc = kTraySideCRPos*SinD(alpharot);
    yloc = kTraySideCRPos*CosD(alpharot);
    moth->AddNode(trayStructure,jt+1,
		       new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
		       new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
  }


  return;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
						   const 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:
//
// 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
//

  // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
  const Double_t kForwardTrayThick        =    2.00 *fgkmm;
  const Double_t kForwardTraySideLength   =  823.00 *fgkmm;
  const Double_t kForwardTrayTailLength   =  212.00 *fgkmm;
  const Double_t kForwardTrayBaseHalfWide =   55.00 *fgkmm;
  const Double_t kForwardTrayNotchLength  =   47.20 *fgkmm;
  const Double_t kForwardTrayNotchHeight  =   25.00 *fgkmm;
  const Double_t kForwardTrayNotchDown    =   10.00 *fgkmm;
  const Double_t kForwardTraySide1Height  =   39.00 *fgkmm;
  const Double_t kForwardTraySide2Height  =   26.00 *fgkmm;
  const Double_t kForwardTraySide2Expand  =   10.50 *fgkmm;
  const Double_t kForwardTraySide3TailLen =  418.00 *fgkmm;
  const Double_t kForwardTraySide3TailHi  =   31.00 *fgkmm;
  const Double_t kForwardTraySide3HeadLen =  425.00 *fgkmm;
  const Double_t kForwardTraySide3HeadHi  =   72.00 *fgkmm;
  const Double_t kForwardTrayHorWingWide  =   10.50 *fgkmm;
  const Double_t kForwardTrayVertWingWide =   15.00 *fgkmm;

  const Int_t    kForwardTraySideNpoints  =    9;


  // Local variables
  Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
  Double_t ylen, zlen;
  Double_t xloc, yloc, zloc;


  // The tray has a very complex shape, so it is made by assembling
  // different elements (with some small simplifications)

  // The tray base: a BBox
  zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
  TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
				    kForwardTrayThick/2, zlen);

  // The first part of the side wall: a Xtru
  TGeoXtru *traySide1 = new TGeoXtru(2);

  xprof[0] = 0;
  yprof[0] = kForwardTrayThick;
  xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
  yprof[1] = yprof[0];
  xprof[2] = kForwardTraySideLength;
  yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
  xprof[3] = 0;
  yprof[3] = yprof[2];

  traySide1->DefinePolygon(4, xprof, yprof);
  traySide1->DefineSection(0, 0);
  traySide1->DefineSection(1, kForwardTrayThick);

  // The second part of the side wall: a Xtru
  TGeoXtru *traySide2 = new TGeoXtru(2);

  xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
  yprof[0] = traySide1->GetY(2);
  xprof[1] = kForwardTrayBaseHalfWide;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1] + kForwardTraySide2Expand;
  yprof[2] = yprof[1] + kForwardTraySide2Height;
  xprof[3] = xprof[2] - kForwardTrayThick;
  yprof[3] = yprof[2];

  traySide2->DefinePolygon(4, xprof, yprof);
  traySide2->DefineSection(0, 0);
  traySide2->DefineSection(1, kForwardTraySideLength);

  // The third part of the side wall: a Xtru
  TGeoXtru *traySide3 = new TGeoXtru(2);

  xprof[0] = 0;
  yprof[0] = traySide2->GetY(2);
  xprof[1] = kForwardTraySideLength;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
  xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
  xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = yprof[5] - kForwardTrayNotchHeight;
  xprof[7] = xprof[6] + kForwardTrayNotchLength;
  yprof[7] = yprof[6];
  xprof[8] = xprof[7];
  yprof[8] = yprof[7] - kForwardTrayNotchDown;

  traySide3->DefinePolygon(9, xprof, yprof);
  traySide3->DefineSection(0, 0);
  traySide3->DefineSection(1, kForwardTrayThick);

  // The horizontal wing: a BBox
  TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
				       kForwardTrayThick/2,
				       kForwardTraySide3TailLen/2);

  // The vertical wing: a BBox
  ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
  TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
					ylen, kForwardTrayThick/2);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");

  TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
					    trayBase, medAl);

  forwTrayBase->SetVisibility(kTRUE);
  forwTrayBase->SetLineColor(6); // Purple
  forwTrayBase->SetLineWidth(1);
  forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
  forwTrayBase->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
					    traySide1, medAl);

  forwTraySide1->SetVisibility(kTRUE);
  forwTraySide1->SetLineColor(6); // Purple
  forwTraySide1->SetLineWidth(1);
  forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
  forwTraySide1->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
					    traySide2, medAl);

  forwTraySide2->SetVisibility(kTRUE);
  forwTraySide2->SetLineColor(6); // Purple
  forwTraySide2->SetLineWidth(1);
  forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
  forwTraySide2->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
					    traySide3, medAl);

  forwTraySide3->SetVisibility(kTRUE);
  forwTraySide3->SetLineColor(6); // Purple
  forwTraySide3->SetLineWidth(1);
  forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
  forwTraySide3->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
					    trayHorWing, medAl);

  forwTrayHWing->SetVisibility(kTRUE);
  forwTrayHWing->SetLineColor(6); // Purple
  forwTrayHWing->SetLineWidth(1);
  forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
  forwTrayHWing->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
					    trayVertWing, medAl);

  forwTrayVWing->SetVisibility(kTRUE);
  forwTrayVWing->SetLineColor(6); // Purple
  forwTrayVWing->SetLineWidth(1);
  forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
  forwTrayVWing->SetFillStyle(4000); // 0% transparent


  // Now build up the tray
  yloc = kForwardTrayThick/2;
  zloc = zlen;
  tray->AddNode(forwTrayBase, 1,
		new TGeoTranslation(0, yloc, zloc) );

  xloc = kForwardTrayBaseHalfWide;
  tray->AddNode(forwTraySide1, 1,
		new TGeoCombiTrans(xloc, 0, 0,
				   new TGeoRotation("",90,-90,-90)));
  xloc = -xloc + kForwardTrayThick;
  tray->AddNode(forwTraySide1, 2,
		new TGeoCombiTrans(xloc, 0, 0,
				   new TGeoRotation("",90,-90,-90)));

  tray->AddNode(forwTraySide2, 1, 0);
  zloc = kForwardTraySideLength;
  tray->AddNode(forwTraySide2, 2,
		new TGeoCombiTrans(0, 0, zloc,
				   new TGeoRotation("",90,-180,-90)));

  xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
  tray->AddNode(forwTraySide3, 1,
		new TGeoCombiTrans(xloc, 0, 0,
				   new TGeoRotation("",90,-90,-90)));
  xloc = -xloc + kForwardTrayThick;
  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();
  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;
  tray->AddNode(forwTrayVWing, 1,
		new TGeoTranslation( xloc, yloc, zloc) );
  tray->AddNode(forwTrayVWing, 2,
		new TGeoTranslation(-xloc, yloc, zloc) );


  return;
}

//______________________________________________________________________
TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
//
// Creates the forward cover of the SDD and SSD cable trays on Side A
// (0872/G/D/02)
//
// Input:
//             coverLen: the total length of the cover
//
// Output:
//
// Return:     a TGeoCompositeShape for the cover
//
// Created:      03 Jan 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
//

  // Dimensions and positions of the A-Side Cable Tray Forward Cover
  // (0872/G/D/02)
  const Double_t kForwardCoverWide        =  130.00 *fgkmm;
  const Double_t kForwardCoverSideWide    =   10.00 *fgkmm;
  const Double_t kForwardCoverHoleLen     =  160.00 *fgkmm;
  const Double_t kForwardCoverHoleWide    =   90.00 *fgkmm;
  const Double_t kForwardCoverHoleR10     =   10.00 *fgkmm;
  const Double_t kForwardCoverTotalThick  =    5.00 *fgkmm;
  const Double_t kForwardCoverSideThick   =    3.00 *fgkmm;
  const Double_t kForwardCoverInternThick =    2.00 *fgkmm;

  const Double_t kForwardCoverHoleZTrans  =   40.00 *fgkmm;


  // Local variables
  Double_t xprof[16], yprof[16];
  Double_t yloc, zloc;


  // The main shape: a Xtru
  TGeoXtru *forwCoverMain = new TGeoXtru(2);
  forwCoverMain->SetName("ITSsuppForwCoverMain");

  xprof[0] = kForwardCoverWide/2;
  yprof[0] = kForwardCoverTotalThick;
  xprof[1] = xprof[0];
  yprof[1] = yprof[0] - kForwardCoverSideThick;
  xprof[2] = xprof[1] - kForwardCoverSideWide;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = 0;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 4; jp++) {
    xprof[4+jp] = -xprof[3-jp];
    yprof[4+jp] =  yprof[3-jp];
  }

  // And now the actual Xtru
  forwCoverMain->DefinePolygon(8, xprof, yprof);
  forwCoverMain->DefineSection(0, 0);
  forwCoverMain->DefineSection(1, coverLen);

  // The hole: another Xtru (rounded corners approximated with segments)
  TGeoXtru *forwCoverHole = new TGeoXtru(2);
  forwCoverHole->SetName("ITSsuppForwCoverHole");

  CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
			     kForwardCoverHoleR10 , xprof, yprof);

  // And now the actual Xtru
  forwCoverHole->DefinePolygon(16, xprof, yprof);
  forwCoverHole->DefineSection(0, 0);
  forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);

  // Now the proper rototranslation matrices for the two holes
  yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
  zloc = kForwardCoverHoleZTrans;
  TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  mf1->SetName("mf1");
  mf1->RegisterYourself();

  zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
  TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  mf2->SetName("mf2");
  mf2->RegisterYourself();

  // Finally the actual cover shape
  TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
    "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");

  return cover;
}

//______________________________________________________________________
TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
//
// Creates the external cover of the SDD and SSD cable trays on Side A
// (0872/G/D/04)
//
// Input:
//             coverLen: the total length of the cover
//
// Output:
//
// Return:     a TGeoCompositeShape for the cover
//
// Created:      03 Jan 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
//

  // Dimensions and positions of the A-Side Cable Tray External Cover
  // (0872/G/D/04)
  const Double_t kExternalCoverWide        =  130.00 *fgkmm;
  const Double_t kExternalCoverSideWide    =   10.00 *fgkmm;
  const Double_t kExternalCoverHoleLen1    =  262.00 *fgkmm;
  const Double_t kExternalCoverHoleLen2    =  280.00 *fgkmm;
  const Double_t kExternalCoverHoleLen3    =  205.00 *fgkmm;
  const Double_t kExternalCoverHoleLen4    =   55.00 *fgkmm;
  const Double_t kExternalCoverHoleWide    =   90.00 *fgkmm;
  const Double_t kExternalCoverHoleR10     =   10.00 *fgkmm;
  const Double_t kExternalCoverTotalThick  =    5.00 *fgkmm;
  const Double_t kExternalCoverSideThick   =    3.00 *fgkmm;
  const Double_t kExternalCoverInternThick =    2.00 *fgkmm;

  const Double_t kExternalCoverHole1ZTrans =   28.00 *fgkmm;
  const Double_t kExternalCoverHolesZTrans =   20.00 *fgkmm;


  // Local variables
  Double_t xprof[16], yprof[16];
  Double_t yloc, zloc;


  // The main shape: a Xtru
  TGeoXtru *externCoverMain = new TGeoXtru(2);
  externCoverMain->SetName("ITSsuppExternCoverMain");

  xprof[0] = kExternalCoverWide/2;
  yprof[0] = kExternalCoverTotalThick;
  xprof[1] = xprof[0];
  yprof[1] = yprof[0] - kExternalCoverSideThick;
  xprof[2] = xprof[1] - kExternalCoverSideWide;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = 0;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 4; jp++) {
    xprof[4+jp] = -xprof[3-jp];
    yprof[4+jp] =  yprof[3-jp];
  }

  // And now the actual Xtru
  externCoverMain->DefinePolygon(8, xprof, yprof);
  externCoverMain->DefineSection(0, 0);
  externCoverMain->DefineSection(1, coverLen);

  // The first hole: a Xtru (rounded corners approximated with segments)
  Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;

  TGeoXtru *extCoverHole1 = new TGeoXtru(2);
  extCoverHole1->SetName("ITSsuppExtCoverHole1");

  CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
			     kExternalCoverHoleR10 , xprof, yprof);

  extCoverHole1->DefinePolygon(16, xprof, yprof);
  extCoverHole1->DefineSection(0, 0);
  extCoverHole1->DefineSection(1, holethick);

  // The second (and third) hole: another Xtru
  TGeoXtru *extCoverHole2 = new TGeoXtru(2);
  extCoverHole2->SetName("ITSsuppExtCoverHole2");

  CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
			     kExternalCoverHoleR10 , xprof, yprof);

  extCoverHole2->DefinePolygon(16, xprof, yprof);
  extCoverHole2->DefineSection(0, 0);
  extCoverHole2->DefineSection(1, holethick);

  // The fourth hole: another Xtru
  TGeoXtru *extCoverHole3 = new TGeoXtru(2);
  extCoverHole3->SetName("ITSsuppExtCoverHole3");

  CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
			     kExternalCoverHoleR10 , xprof, yprof);

  extCoverHole3->DefinePolygon(16, xprof, yprof);
  extCoverHole3->DefineSection(0, 0);
  extCoverHole3->DefineSection(1, holethick);

  // The fifth and last hole: another Xtru
  TGeoXtru *extCoverHole4 = new TGeoXtru(2);
  extCoverHole4->SetName("ITSsuppExtCoverHole4");

  CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
			     kExternalCoverHoleR10 , xprof, yprof);

  extCoverHole4->DefinePolygon(16, xprof, yprof);
  extCoverHole4->DefineSection(0, 0);
  extCoverHole4->DefineSection(1, holethick);

  // Now the proper rototranslation matrices for the holes
  yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
  zloc = kExternalCoverHole1ZTrans;
  TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  me1->SetName("me1");
  me1->RegisterYourself();

  zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
  TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  me2->SetName("me2");
  me2->RegisterYourself();

  zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
  TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  me3->SetName("me3");
  me3->RegisterYourself();

  zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
  TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  me4->SetName("me4");
  me4->RegisterYourself();

  zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
  TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
					   new TGeoRotation("", 0, 90, 0) );
  me5->SetName("me5");
  me5->RegisterYourself();

  // Finally the actual cover shape
  TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
    "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");

  return cover;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
			       const Double_t length, const Double_t r10,
			       Double_t *x, Double_t *y){
//
// Creates the proper sequence of X and Y coordinates to determine
// the base XTru polygon for the holes in the SDD and SSD tray covers
// (here the rounded corners are approximated with segments)
//
// Input:
//        wide   : the hole wide
//        length : the hole length
//        r10    : the radius of the rounded corners
//
// Output:
//        x, y : coordinate vectors [16]
//
// Created:      03 Jan 2010  Mario Sitta
//
// Caller must guarantee that x and y have the correct dimensions
// (but being this a private method it's easy to tell)
//

  x[0] = wide/2 - r10;
  y[0] = length;
  x[1] = x[0] + r10*SinD(30);
  y[1] = y[0] - r10*(1 - CosD(30));
  x[2] = x[0] + r10*SinD(60);
  y[2] = y[0] - r10*(1 - CosD(60));
  x[3] = x[0] + r10;
  y[3] = y[0] - r10;
  x[4] = x[3];
  y[4] = r10;
  x[5] = x[4] - r10*(1 - CosD(30));
  y[5] = y[4] - r10*SinD(30);
  x[6] = x[4] - r10*(1 - CosD(60));
  y[6] = y[4] - r10*SinD(60);
  x[7] = x[4] - r10;
  y[7] = 0;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 8; jp++) {
    x[8+jp] = -x[7-jp];
    y[8+jp] =  y[7-jp];
  }

  return;
}

//______________________________________________________________________
TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
					      const Double_t trayLen,
					      const Double_t trayHi){
//
// Creates parts of the SDD and SSD Trays on Side A which are identical
// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
//
// Input:
//         trayLen : the length of the tray part
//         trayHi  : the height of the tray part
//
// Output:
//
// Return:     a TGeoXtru
//
// Created:      26 Feb 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
//

  // Dimensions and positions of the A-Side Cable Trays
  // (parts of 0872/G/C)
  const Double_t kTrayWidth              =  130.00 *fgkmm;
  const Double_t kTrayWingWidth          =   10.00 *fgkmm;
  const Double_t kTrayHeightToBend       =   20.00 *fgkmm;
  const Double_t kTrayThick              =    2.00 *fgkmm;

  const Double_t kTrayBendAngle          =   22.00 *TMath::DegToRad();

  const Int_t    kTrayNpoints            =   16;

  // Local variables
  Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];


  // The tray shape: a Xtru
  TGeoXtru *trayPart = new TGeoXtru(2);

  xprof[2] = kTrayWidth/2 - kTrayThick;
  yprof[2] = trayHi - kTrayThick;
  xprof[3] = kTrayWidth/2 - kTrayWingWidth;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = trayHi;
  xprof[5] = kTrayWidth/2;
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = kTrayHeightToBend;
  xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
  yprof[7] = 0;

  InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
	      -kTrayThick, xprof[1], yprof[1]);

  xprof[8] = -xprof[7];
  yprof[8] =  yprof[7];

  InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
	      -kTrayThick, xprof[0], yprof[0]);

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 8; jp++) {
    xprof[8+jp] = -xprof[7-jp];
    yprof[8+jp] =  yprof[7-jp];
  }

  // And now the actual Xtru
  trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
  trayPart->DefineSection(0, 0);
  trayPart->DefineSection(1, trayLen);


  return trayPart;
}

//______________________________________________________________________
TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
						       const char *trayName,
						       const TGeoManager *mgr){

//
// Creates the SDD and SSD Trays on Side C which are supposedly identical
//
// Input:
//         trayName : the assembly name
//
// Output:
//
// Return:     a TGeoVolumeAssembly
//
// Created:      16 Apr 2010  Mario Sitta
//
// Technical data are taken from AutoCAD drawings and other (oral)
// information given by F.Tosello
//

  const Double_t kSideCHalfThick      =    0.100   *fgkcm;
  const Double_t kSideCFoldAngle      =    5.000   *TMath::DegToRad();

  const Double_t kSideCLength1        =  172.800   *fgkcm;
  const Double_t kSideCLength2        =  189.300   *fgkcm;
  const Double_t kSideCHalfWide       =    6.350   *fgkcm;
  const Double_t kSideCHeight1        =   11.800   *fgkcm;
  const Double_t kSideCHeight2        =    4.300   *fgkcm;
  const Double_t kSideCSideLength1    =   10.800   *fgkcm;
  const Double_t kSideCSideLength2    =   63.800   *fgkcm;
  const Double_t kSideCSideHeight     =    8.800   *fgkcm;
  const Int_t    kNPointsLowerFace    =    6;
  const Int_t    kNPointsLateralFace  =    9;

  const Double_t kSideCWingAHalfLen   =    5.000   *fgkcm;
  const Double_t kSideCWingBHalfLen   =   30.500   *fgkcm;
  const Double_t kSideCWingCHalfLen   =    2.000   *fgkcm;
  const Double_t kSideCWingDHalfLen   =   48.500   *fgkcm;
  const Double_t kSideCWingEHalfLen   =   83.000   *fgkcm;
  const Double_t kSideCWingsHalfWide  =    0.450   *fgkcm;

  const Int_t    kNPointsCoverFace    =   12;

  const Double_t kPlateHalfLen        =    6.000   *fgkcm;
  const Double_t kPlateThick          =    0.600   *fgkcm;
  const Double_t kPlateHeight         =    4.200   *fgkcm;
  const Int_t    kNPointsPlate        =    6;

  const Double_t kBarCoolRmax         =    0.4     *fgkcm;
  const Int_t    kNumBarCool          =    2;
  const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
  const Double_t kYShiftBarCool[kNumBarCool] = { 8.5,  5.0 };


  // Local variables
  Double_t xprof[12], yprof[12];
  Double_t xloc, yloc, zloc, delta, alpharot;

  // The single C-Side Cable tray as an assembly
  TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);

  // First create all needed shapes

  // The Cable Tray lower face: a Xtru
  TGeoXtru *sideCLowerFace = new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kSideCLength1;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
  yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
  xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
  yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      2*kSideCHalfThick , xprof[4], yprof[4]);
  xprof[5] = 0.;
  yprof[5] = 2*kSideCHalfThick;

  sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
  sideCLowerFace->DefineSection(0,-kSideCHalfWide);
  sideCLowerFace->DefineSection(1, kSideCHalfWide);

  // The Cable Tray lateral face: a Xtru
  TGeoXtru *sideCLateralFace = new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kSideCLength1;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
  yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
  xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
  yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kSideCHeight2, xprof[4], yprof[4]);
  xprof[5] = kSideCSideLength1 + kSideCSideLength2;
  yprof[5] = kSideCHeight2;
  xprof[6] = xprof[5];
  yprof[6] = kSideCSideHeight;
  xprof[7] = kSideCSideLength1;
  yprof[7] = kSideCHeight1;
  xprof[8] = 0;
  yprof[8] = yprof[7];

  sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
  sideCLateralFace->DefineSection(0,-kSideCHalfThick);
  sideCLateralFace->DefineSection(1, kSideCHalfThick);

  // The lateral wings: four BBox's
  TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
					     kSideCHalfThick,
					     kSideCWingsHalfWide);

  TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
					     kSideCHalfThick,
					     kSideCWingsHalfWide);

  TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick,    // With these
					     kSideCWingCHalfLen, // X,Y avoid
					     kSideCWingsHalfWide);//rotations

  TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
					     kSideCHalfThick,
					     kSideCWingsHalfWide);

  TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
					     kSideCHalfThick,
					     kSideCWingsHalfWide);

  // The connecting lower plate: a Xtru
  TGeoXtru *sideCLowerPlate =  new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kPlateHalfLen;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
  yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
  xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
  yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kPlateThick, xprof[4], yprof[4]);
  xprof[5] = 0.;
  yprof[5] = kPlateThick;

  sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
  Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
  sideCLowerPlate->DefineSection(0,-zwide);
  sideCLowerPlate->DefineSection(1, zwide);

  // The connecting side plate: a Xtru
  TGeoXtru *sideCLateralPlate = new TGeoXtru(2);

  xprof[0] = 0.;
  yprof[0] = 0.;
  xprof[1] = kPlateHalfLen;
  yprof[1] = 0.;
  xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
  yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
  xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
  yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
	      kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
  xprof[5] = 0.;
  yprof[5] = kPlateHeight;

  sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
  sideCLateralPlate->DefineSection(0,-kPlateThick/2);
  sideCLateralPlate->DefineSection(1, kPlateThick/2);

  // The bar fixing the cooling tubes: a Tube
  TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);

  // The Cable Tray cover: a (complex) Xtru
  TGeoXtru *sideCCoverFace = new TGeoXtru(2);

  xprof[ 0] = sideCLateralFace->GetX(8);
  yprof[ 0] = sideCLateralFace->GetY(8);
  xprof[ 1] = sideCLateralFace->GetX(7);
  yprof[ 1] = sideCLateralFace->GetY(7);
  xprof[ 2] = sideCLateralFace->GetX(6);
  yprof[ 2] = sideCLateralFace->GetY(6);
  xprof[ 3] = sideCLateralFace->GetX(5);
  yprof[ 3] = sideCLateralFace->GetY(5);
  xprof[ 4] = sideCLateralFace->GetX(4);
  yprof[ 4] = sideCLateralFace->GetY(4);

  xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
  delta  = kSideCLength1 - (xloc + kSideCWingDHalfLen);
  xprof[ 5] = xprof[4]
	    + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
  yprof[ 5] = yprof[4]
	    + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);

  xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
  yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
  InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
	      2*kSideCHalfThick, xprof[7], yprof[7]);
  InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
	      2*kSideCHalfThick, xprof[8], yprof[8]);
  xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
  yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
  xprof[10] = xprof[1];
  yprof[10] = yprof[1] + 2*kSideCHalfThick;
  xprof[11] = xprof[0];
  yprof[11] = yprof[0] + 2*kSideCHalfThick;

  sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
  zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
  sideCCoverFace->DefineSection(0,-zloc);
  sideCCoverFace->DefineSection(1, zloc);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAl      = mgr->GetMedium("ITS_ALUMINUM$");

  TGeoVolume *traySideCLowerFace  = new TGeoVolume("ITSsuppTraySideCLower",
						   sideCLowerFace, medAl);

  traySideCLowerFace->SetVisibility(kTRUE);
  traySideCLowerFace->SetLineColor(6); // Purple
  traySideCLowerFace->SetLineWidth(1);
  traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
  traySideCLowerFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralFace  = new TGeoVolume("ITSsuppTraySideCLateral",
						     sideCLateralFace, medAl);

  traySideCLateralFace->SetVisibility(kTRUE);
  traySideCLateralFace->SetLineColor(6); // Purple
  traySideCLateralFace->SetLineWidth(1);
  traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
  traySideCLateralFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralWingA =
    new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA,  medAl);

  traySideCLateralWingA->SetVisibility(kTRUE);
  traySideCLateralWingA->SetLineColor(6); // Purple
  traySideCLateralWingA->SetLineWidth(1);
  traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
  traySideCLateralWingA->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralWingB =
    new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB,  medAl);

  traySideCLateralWingB->SetVisibility(kTRUE);
  traySideCLateralWingB->SetLineColor(6); // Purple
  traySideCLateralWingB->SetLineWidth(1);
  traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
  traySideCLateralWingB->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralWingC =
    new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC,  medAl);

  traySideCLateralWingC->SetVisibility(kTRUE);
  traySideCLateralWingC->SetLineColor(6); // Purple
  traySideCLateralWingC->SetLineWidth(1);
  traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
  traySideCLateralWingC->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralWingD =
    new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD,  medAl);

  traySideCLateralWingD->SetVisibility(kTRUE);
  traySideCLateralWingD->SetLineColor(6); // Purple
  traySideCLateralWingD->SetLineWidth(1);
  traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
  traySideCLateralWingD->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralWingE =
    new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE,  medAl);

  traySideCLateralWingE->SetVisibility(kTRUE);
  traySideCLateralWingE->SetLineColor(6); // Purple
  traySideCLateralWingE->SetLineWidth(1);
  traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
  traySideCLateralWingE->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLowerPlate =
    new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate,  medAl);

  traySideCLowerPlate->SetVisibility(kTRUE);
  traySideCLowerPlate->SetLineColor(6); // Purple
  traySideCLowerPlate->SetLineWidth(1);
  traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
  traySideCLowerPlate->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCLateralPlate =
    new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate,  medAl);

  traySideCLateralPlate->SetVisibility(kTRUE);
  traySideCLateralPlate->SetLineColor(6); // Purple
  traySideCLateralPlate->SetLineWidth(1);
  traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
  traySideCLateralPlate->SetFillStyle(4000); // 0% transparent

  TGeoVolume *traySideCCoverFace =
    new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace,  medAl);

  traySideCCoverFace->SetVisibility(kTRUE);
  traySideCCoverFace->SetLineColor(6); // Purple
  traySideCCoverFace->SetLineWidth(1);
  traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
  traySideCCoverFace->SetFillStyle(4000); // 0% transparent

  TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
					      coolBar, medAl);

  coolingTubeBar->SetVisibility(kTRUE);
  coolingTubeBar->SetLineColor(6); // Purple
  coolingTubeBar->SetLineWidth(1);
  coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
  coolingTubeBar->SetFillStyle(4000); // 0% transparent


  // Now build up the tray
  cableTrayC->AddNode(traySideCLowerFace,1,0);

  zloc = kSideCHalfWide + kSideCHalfThick;
  cableTrayC->AddNode(traySideCLateralFace,1,
			    new TGeoTranslation(0., 0., zloc) );
  cableTrayC->AddNode(traySideCLateralFace,2,
			    new TGeoTranslation(0., 0.,-zloc) );

  xloc = kSideCWingAHalfLen;
  yloc = kSideCHeight1 - kSideCHalfThick;
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
  cableTrayC->AddNode(traySideCLateralWingA,1,
			    new TGeoTranslation(xloc, yloc, zloc) );
  cableTrayC->AddNode(traySideCLateralWingA,2,
			    new TGeoTranslation(xloc, yloc,-zloc) );

  xloc = kSideCSideLength1 + kSideCSideLength2/2;
  yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
		      kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
		      xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
  alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
		TMath::RadToDeg();
  cableTrayC->AddNode(traySideCLateralWingB,1,
			    new TGeoCombiTrans(xloc, yloc, zloc,
					new TGeoRotation("",alpharot,0,0) ) );
  cableTrayC->AddNode(traySideCLateralWingB,2,
			    new TGeoCombiTrans(xloc, yloc,-zloc,
					new TGeoRotation("",alpharot,0,0) ) );

  xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
  yloc = kSideCSideHeight - kSideCWingCHalfLen;
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
  cableTrayC->AddNode(traySideCLateralWingC,1,
			    new TGeoTranslation(xloc, yloc, zloc) );
  cableTrayC->AddNode(traySideCLateralWingC,2,
			    new TGeoTranslation(xloc, yloc,-zloc) );

  xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
  yloc = kSideCHeight2 - kSideCHalfThick;
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
  cableTrayC->AddNode(traySideCLateralWingD,1,
			    new TGeoTranslation(xloc, yloc, zloc) );
  cableTrayC->AddNode(traySideCLateralWingD,2,
			    new TGeoTranslation(xloc, yloc,-zloc) );

  delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
  xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
  yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
	  kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
  alpharot = kSideCFoldAngle*TMath::RadToDeg();
  cableTrayC->AddNode(traySideCLateralWingE,1,
			    new TGeoCombiTrans(xloc, yloc, zloc,
					new TGeoRotation("",alpharot,0,0) ) );
  cableTrayC->AddNode(traySideCLateralWingE,2,
			    new TGeoCombiTrans(xloc, yloc,-zloc,
					new TGeoRotation("",alpharot,0,0) ) );

  xloc = kSideCLength1 - kPlateHalfLen;
  yloc = -kPlateThick -0.0025; // Avoid small overlap
  cableTrayC->AddNode(traySideCLowerPlate,1,
			    new TGeoTranslation(xloc, yloc, 0.) );

  xloc = kSideCLength1 - kPlateHalfLen;
  yloc = -kPlateThick;
  zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
  cableTrayC->AddNode(traySideCLateralPlate,1,
			    new TGeoTranslation(xloc, yloc, zloc) );
  cableTrayC->AddNode(traySideCLateralPlate,2,
			    new TGeoTranslation(xloc, yloc,-zloc) );

  for (Int_t jc = 0; jc <kNumBarCool; jc++) {
    xloc = kXShiftBarCool[jc];
    yloc = kYShiftBarCool[jc];
    cableTrayC->AddNode(coolingTubeBar,jc+1,
			      new TGeoTranslation(xloc, yloc, 0.) );
  }

  cableTrayC->AddNode(traySideCCoverFace,1,0);


  // Finally return what we made up

  return cableTrayC;
}

//______________________________________________________________________
void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
					const TGeoManager *mgr){
//
// Creates the elements suspending the ITS to the TPC and other fixed
// elements used to hook the rails (0872/C and its daughters)
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (default gGeoManager)
// Output:
//
// Return:
//
// Created:      28 Oct 2010  Mario Sitta
// Updated:      18 Feb 2011  Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
//

  // Dimensions and positions of the half ring C2/C3 (0872/C/04)
  const Double_t kRingCZPos           =   733.000*fgkmm;
  const Double_t kRingCZToTPC         =     5.500*fgkmm;

  const Double_t kRingCThick          =    12.000*fgkmm;
  const Double_t kRingCRmin           =   565.000*fgkmm;
  const Double_t kRingCRmax           =   592.000*fgkmm;
  const Double_t kRingCHeight         =   560.000*fgkmm;
  const Double_t kRingCXToInsert      =   515.000*fgkmm;
  const Double_t kRingCYToInsert      =   113.000*fgkmm;

  const Int_t kNumberOfRingPoints     =    23; // N.points to approximate arc

  // Dimensions of the forward upper hook (0872/C/09)
  const Double_t kForwUpHookThick     =    20.000*fgkmm;
  const Double_t kForwUpHookRext      =   590.000*fgkmm;
  const Double_t kForwUpHookRint      =    20.000*fgkmm;
  const Double_t kForwUpHookHiTot     =    89.000*fgkmm;
  const Double_t kForwUpHookHiInt     =    59.000*fgkmm;
  const Double_t kForwUpHookWide      =    96.000*fgkmm;
  const Double_t kForwUpHookHalfBase  =    25.000*fgkmm;
  const Double_t kForwUpHookBaseCut   =    10.000*fgkmm;
  const Double_t kForwUpHookHoleWide  =    25.000*fgkmm;
  const Double_t kForwUpHookHoleHi    =    22.500*fgkmm;
  const Double_t kForwUpHookHoleBase  =     5.000*fgkmm;
  const Double_t kForwUpHookHoleR5    =     5.000*fgkmm;
  const Double_t kForwUpHookHoleY     =     8.000*fgkmm;
  const Double_t kForwUpHookHollowHi  =    35.000*fgkmm;
  const Double_t kForwUpHookHollowWide=     5.000*fgkmm;

  const Int_t kNumberOfForwUpHookPts  =    11;
  const Int_t kNumbOfForwUpHookHolePts=     5;

  // Dimensions of the forward lower hook (0872/C/08)
  const Double_t kForwLwHookThick     =    20.000*fgkmm;
  const Double_t kForwLwHookRext      =   590.000*fgkmm;
  const Double_t kForwLwHookRint      =    20.000*fgkmm;
  const Double_t kForwLwHookHiTot     =    88.500*fgkmm;
  const Double_t kForwLwHookWide      =    96.000*fgkmm;
  const Double_t kForwLwHookHalfBase  =    25.000*fgkmm;
  const Double_t kForwLwHookBaseCut   =    10.000*fgkmm;
  const Double_t kForwLwHookYToHollow =     3.500*fgkmm;
  const Double_t kForwLwHookHoleR     =     7.500*fgkmm;
  const Double_t kForwLwHookHoleIntHi =    35.000*fgkmm;
  const Double_t kForwLwHookHoleYPos  =    13.500*fgkmm;
  const Double_t kForwLwHookHollowHi  =    62.000*fgkmm;
  const Double_t kForwLwHookHollowWide=     5.000*fgkmm;

  const Int_t kNumberOfForwLwHookPts  =    11;
  const Int_t kNumbOfForwLwHookHolePts=     7;

  // Dimensions of the rear upper hook (0872/C/10)
  const Double_t kRearUpHookThick     =    15.000*fgkmm;
  const Double_t kRearUpHookRext      =   590.000*fgkmm;
  const Double_t kRearUpHookRint      =    20.000*fgkmm;
  const Double_t kRearUpHookHiTot     =    53.500*fgkmm;
  const Double_t kRearUpHookHiInt     =    23.500*fgkmm;
  const Double_t kRearUpHookWide      =    96.000*fgkmm;
  const Double_t kRearUpHookHalfBase  =    25.000*fgkmm;
  const Double_t kRearUpHookHoleWide  =    25.000*fgkmm;
  const Double_t kRearUpHookHoleHi    =    22.500*fgkmm;
  const Double_t kRearUpHookHoleBase  =     5.000*fgkmm;
  const Double_t kRearUpHookHoleR5    =     5.000*fgkmm;
  const Double_t kRearUpHookHoleY     =     8.000*fgkmm;

  const Int_t kNumberOfRearUpHookPts  =    10;
  const Int_t kNumbOfRearUpHookHolePts=     5;

  // Dimensions of the forward lower hook (0872/C/11)
  const Double_t kRearLwHookThick     =    20.000*fgkmm;
  const Double_t kRearLwHookRext      =   590.000*fgkmm;
  const Double_t kRearLwHookHiTot     =    30.000*fgkmm;
  const Double_t kRearLwHookWide      =    96.000*fgkmm;

  const Int_t kNumberOfRearLwHookPts  =     3;

  // Dimensions of the rear lower brackets (0872/C/16)
  const Double_t kRearLwBracketThick  =    15.000*fgkmm;
  const Double_t kRearLwBracketHi1    =    42.000*fgkmm;
  const Double_t kRearLwBracketHi2    =    12.000*fgkmm;
  const Double_t kRearLwBracketWide1  =    34.000*fgkmm;
  const Double_t kRearLwBracketWide2  =    10.000*fgkmm;
//  const Double_t kRearLwBracketR5     =     5.000*fgkmm

  // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
  const Double_t kForwWebSStirrDep    =    20.000*fgkmm;
  const Double_t kForwWebSStirrLen1   =    15.000*fgkmm;
  const Double_t kForwWebSStirrLen2   =    55.000*fgkmm;
  const Double_t kForwWebSStirrLen3   =    10.000*fgkmm;
  const Double_t kForwWebSStirrWide1  =    45.000*fgkmm;
  const Double_t kForwWebSStirrWide2  =    38.000*fgkmm;
  const Double_t kForwWebSStirrWide3  =    23.000*fgkmm;
  const Double_t kForwWebTStirrThick  =     5.000*fgkmm;
  const Double_t kForwWebTStirrWide1  =    30.000*fgkmm;
  const Double_t kForwWebTStirrWide2  =    10.000*fgkmm;
  const Double_t kForwWebTStirrTotLen3=    58.500*fgkmm;
  const Double_t kForwWebTStirrTotLen4=    36.000*fgkmm;
  const Double_t kForwWebTStirrLen1   =    10.000*fgkmm;

  // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
  const Double_t kFRWebClampThick     =    10.000*fgkmm;
  const Double_t kFRWebClampExtWide   =    30.000*fgkmm;
  const Double_t kFRWebClampIntWide   =    18.000*fgkmm;
  const Double_t kFRWebClampExtHi     =    22.000*fgkmm;
  const Double_t kFRWebClampIntHi     =    17.000*fgkmm;

  // Dimensions of the webcam itself
  const Double_t kWebcamLength        =    35.000*fgkmm;//ESTIMATED!!!

  // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
  const Double_t kRearUpWebStirrWide  =    76.000*fgkmm;
  const Double_t kRearUpWebStirrDep   =    15.000*fgkmm;
  const Double_t kRearUpWebStirrThick =     5.000*fgkmm;
  const Double_t kRearUpWebStirrH1    =    27.000*fgkmm;
  const Double_t kRearUpWebStirrH2    =    32.000*fgkmm;
  const Double_t kRearUpWebBarLen     =   130.000*fgkmm;
  const Double_t kRearUpWebBarHi      =    20.000*fgkmm;
  const Double_t kRearUpWebBarThick   =     5.000*fgkmm;

  // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
  const Double_t kUpperSlideTotHeight =    93.500*fgkmm;
  const Double_t kUpperSlideBlockHi   =    62.500*fgkmm;
  const Double_t kUpperSlideWidth     =    36.000*fgkmm;
  const Double_t kUpperSlideTotDepth  =    51.000*fgkmm;
  const Double_t kUpperSlideIntDepth  =    36.000*fgkmm;
  const Double_t kUpperSlideStubHi    =    15.000*fgkmm;
  const Double_t kUpperSlideStubDep   =     8.000*fgkmm;
  const Double_t kUpperSlideWheelHi   =    18.500*fgkmm;
  const Double_t kUpperSlideHoleRout  =    11.000*fgkmm;
  const Double_t kUpperSlideHoleRint1 =     9.000*fgkmm;
  const Double_t kUpperSlideHoleRint2 =    11.500*fgkmm;
  const Double_t kUpperSlideHoleH1    =     7.000*fgkmm;
  const Double_t kUpperSlideHoleH2    =    46.000*fgkmm;
  const Double_t kUpperSlideHoleH3    =     1.100*fgkmm;
  const Double_t kUpperSlideHoleXPos  =    20.000*fgkmm;
  const Double_t kUpperSlidePinRmin   =     4.000*fgkmm;
  const Double_t kUpperSlidePinRmax   =     6.000*fgkmm;
  const Double_t kUpperSlidePinH1     =     7.000*fgkmm;
  const Double_t kUpperSlidePinH2     =    46.000*fgkmm;
  const Double_t kUpperSlidePinH3     =    25.500*fgkmm;

  // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
  const Double_t kLowerSlideTotHeight =    80.000*fgkmm;
  const Double_t kLowerSlideBlockHi   =    28.000*fgkmm;
  const Double_t kLowerSlideWidth     =    36.000*fgkmm;
  const Double_t kLowerSlideTotDepth  =    60.000*fgkmm;
  const Double_t kLowerSlideHoleRout  =     9.500*fgkmm;
  const Double_t kLowerSlideHoleRint  =     4.700*fgkmm;
  const Double_t kLowerSlideHoleH1    =    12.000*fgkmm;
  const Double_t kLowerSlideNoseBase  =    40.000*fgkmm;
  const Double_t kLowerSlideNoseBasHi =     6.000*fgkmm;//Computed
  const Double_t kLowerSlideNoseUpWid =    25.000*fgkmm;
  const Double_t kLowerSlideNoseDepth =    10.000*fgkmm;
  const Double_t kLowerSlidePinRmin   =     3.000*fgkmm;
  const Double_t kLowerSlidePinRmax   =     4.000*fgkmm;
  const Double_t kLowerSlidePinH1     =    12.000*fgkmm;
  const Double_t kLowerSlidePinH2     =    10.000*fgkmm;

  // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
  const Double_t kStirrCXPos          =   759.000*fgkmm;
  const Double_t kStirrCZPos          =  1867.000*fgkmm;

  const Double_t kStirrC12Thick       =    15.000*fgkmm;
  const Double_t kStirrC12TotLen      =   314.000*fgkmm;
  const Double_t kStirrC12BodyHalfHi  =    95.000*fgkmm;
  const Double_t kStirrC12BodyLen     =   153.000*fgkmm;
  const Double_t kStirrC12HeadLen     =    50.000*fgkmm;
  const Double_t kStirrC12HeadHalfHi  =   165.000*fgkmm;
  const Double_t kStirrC12HeadIntHi   =   114.000*fgkmm;
  const Double_t kStirrC12HeadIntLen  =    45.000*fgkmm;
  const Double_t kStirrC12TailLen     =    14.000*fgkmm;
  const Double_t kStirrC12R100        =   100.000*fgkmm;
  const Double_t kStirrC12R50         =    50.000*fgkmm;
  const Double_t kStirrC12R10         =    10.000*fgkmm;
  const Double_t kStirrC12HeadAng     =    40.000; // Degree

  const Int_t kNumberOfStirrCPoints   =    23;

  // Dimensions and positions of the C5 rail stirrups (0872/C/05)
  const Double_t kStirrC5BodyLen      =   155.000*fgkmm;


  // Local variables
  Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
  Double_t xpos, ypos, zpos, alpha;
  Double_t xdummy, ydummy;
  

  // First create all needed shapes

  // The Supporting Ring (0872/C/04): a really complex Xtru
  // to approximate the arc with a polyline
  TGeoXtru *ringC2C3 = new TGeoXtru(2);

  for (Int_t j=0; j<11; j++) { // The external arc
    xprof[j] = kRingCRmax*SinD(90*j/10);
    yprof[j] = kRingCRmax*CosD(90*j/10);
  }

  xprof[11] = kRingCRmin;
  yprof[11] = yprof[10];

  alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
  xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
  yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
  xprof[13] = kRingCRmin*TMath::Cos(alpha);
  yprof[13] = kRingCRmin*TMath::Sin(alpha);

  xprof[14] = kRingCXToInsert;
  yprof[14] = yprof[13];

  alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
  xprof[15] = kRingCRmin*TMath::Cos(alpha);
  yprof[15] = kRingCRmin*TMath::Sin(alpha);

  for (Int_t j=7; j>1; j--) { // The internal arc
    xprof[23-j] = kRingCRmin*SinD(90*j/10);
    yprof[23-j] = kRingCRmin*CosD(90*j/10);
  }

  alpha = TMath::ASin(kRingCHeight/kRingCRmin);    // The angle till the notch
  xprof[22] = kRingCRmin*TMath::Cos(alpha);
  yprof[22] = kRingCRmin*TMath::Sin(alpha);

  xprof[23] = xprof[0];
  yprof[23] = yprof[22];

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < 22; jp++) {
    xprof[24+jp] = -xprof[23-1-jp];
    yprof[24+jp] =  yprof[23-1-jp];
  }

  // wow! now the actual Xtru
  ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
  ringC2C3->DefineSection(0, 0);
  ringC2C3->DefineSection(1, kRingCThick);

  // The Forward Upper Hook (0872/C/09): a Composite Shape made of
  // a really complex Xtru to approximate the arc with a polyline,
  // another Xtru for the hole, and a BBox for the hollow
  // The main body
  TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
  forwUpHookMainBody->SetName("ITSforwUpHookMainBody");

  xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
  yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
  xprof[ 1] = kForwUpHookHalfBase;
  yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
  xprof[ 2] = xprof[1];
  yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
  for (Int_t j=1; j<6; j++) {
    xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
    yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
  }
  xprof[ 8] = kForwUpHookWide/2;
  yprof[ 8] = yprof[7];
  xprof[ 9] = xprof[8];
  alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
  yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
  xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
  yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
  xprof[11] = 0;
  yprof[11] = kForwUpHookRext;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
    xprof[12+jp] = -xprof[10-jp];
    yprof[12+jp] =  yprof[10-jp];
  }

  // Now the actual Xtru
  forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
  forwUpHookMainBody->DefineSection(0, 0);
  forwUpHookMainBody->DefineSection(1, kForwUpHookThick);

  // The hole
  TGeoXtru *forwUpHookHole = new TGeoXtru(2);
  forwUpHookHole->SetName("ITSforwUpHookHole");

  xprof[0] = kForwUpHookHoleBase/2;
  yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
  xprof[1] = kForwUpHookHoleWide/2;
  yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
  xprof[2] = xprof[1];
  yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
  xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
  yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
  xprof[4] = xprof[2] - kForwUpHookHoleR5;
  yprof[4] = yprof[0] + kForwUpHookHoleHi;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
    xprof[5+jp] = -xprof[4-jp];
    yprof[5+jp] =  yprof[4-jp];
  }

  // Now the actual Xtru
  forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
  forwUpHookHole->DefineSection(0, -0.1);
  forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);

  // The hollow
  TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
					    0.55*kForwUpHookHollowHi,
					    0.55*kForwUpHookHollowWide);
  forwUpHookHollow->SetName("ITSforwUpHookHollow");

  TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
		      forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
		      forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
  forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
  forwUpHookHollPos->RegisterYourself();

  // Finally the actual shape: a CompositeShape
  TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");

  // The Forward Lower Hook (0872/C/08): a Composite Shape made of
  // a really complex Xtru to approximate the arc with a polyline,
  // another Xtru for the hole, and a BBox for the hollow
  // The main body
  TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
  forwLwHookMainBody->SetName("ITSforwLwHookMainBody");

  xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
  yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
  xprof[ 1] = kForwLwHookHalfBase;
  yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
  xprof[ 2] = xprof[1];
  yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
			  - kForwLwHookRint);
  for (Int_t j=1; j<6; j++) {
    xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
    yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
  }
  xprof[ 8] = kForwLwHookWide/2;
  yprof[ 8] = yprof[7];
  xprof[ 9] = xprof[8];
  alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
  yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
  xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
  yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
  xprof[11] = 0;
  yprof[11] = kForwLwHookRext;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
    xprof[12+jp] = -xprof[10-jp];
    yprof[12+jp] =  yprof[10-jp];
  }

  // Now the actual Xtru
  forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
  forwLwHookMainBody->DefineSection(0, 0);
  forwLwHookMainBody->DefineSection(1, kForwLwHookThick);

  // The hole
  TGeoXtru *forwLwHookHole = new TGeoXtru(2);
  forwLwHookHole->SetName("ITSforwLwHookHole");

  xprof[0] = 0;
  yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
	   - kForwLwHookHoleR;
  for (Int_t j=1; j<3; j++) {
    xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
    yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
  }
  xprof[3] = xprof[0] + kForwLwHookHoleR;
  yprof[3] = yprof[0] + kForwLwHookHoleR;
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
  for (Int_t j=1; j<3; j++) {
    xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
    yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
  }
  xprof[7] = xprof[0];
  yprof[7] = yprof[4] + kForwLwHookHoleR;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
    xprof[8+jp] = -xprof[6-jp];
    yprof[8+jp] =  yprof[6-jp];
  }

  // Now the actual Xtru
  forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
  forwLwHookHole->DefineSection(0, -0.1);
  forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);

  // The hollow
  TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
					    0.55*kForwLwHookHollowHi,
					    0.55*kForwLwHookHollowWide);
  forwLwHookHollow->SetName("ITSforwLwHookHollow");

  TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
		      forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
		      forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
  forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
  forwLwHookHollPos->RegisterYourself();

  // Finally the actual shape: a CompositeShape
  TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");

  // The Rear Upper Hook (0872/C/10): a Composite Shape made of
  // a really complex Xtru to approximate the arc with a polyline,
  // and another Xtru for the hole
  // The main body
  TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
  rearUpHookMainBody->SetName("ITSrearUpHookMainBody");

  xprof[0] = kRearUpHookHalfBase;
  yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
  xprof[1] = xprof[0];
  yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint); 
  for (Int_t j=1; j<6; j++) {
    xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
    yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
  }
  xprof[ 7] = kRearUpHookWide/2;
  yprof[ 7] = yprof[5];
  xprof[ 8] = xprof[7];
  alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
  yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
  xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
  yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
  xprof[10] = 0;
  yprof[10] = kRearUpHookRext;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
    xprof[11+jp] = -xprof[9-jp];
    yprof[11+jp] =  yprof[9-jp];
  }

  // Now the actual Xtru
  rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
  rearUpHookMainBody->DefineSection(0, 0);
  rearUpHookMainBody->DefineSection(1, kRearUpHookThick);

  // The hole
  TGeoXtru *rearUpHookHole = new TGeoXtru(2);
  rearUpHookHole->SetName("ITSrearUpHookHole");

  xprof[0] = kRearUpHookHoleBase/2;
  yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
  xprof[1] = kRearUpHookHoleWide/2;
  yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
  xprof[2] = xprof[1];
  yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
  xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
  yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
  xprof[4] = xprof[2] - kRearUpHookHoleR5;
  yprof[4] = yprof[0] + kRearUpHookHoleHi;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
    xprof[5+jp] = -xprof[4-jp];
    yprof[5+jp] =  yprof[4-jp];
  }

  // Now the actual Xtru
  rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
  rearUpHookHole->DefineSection(0, -0.1);
  rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);

  // Finally the actual shape: a CompositeShape
  TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");

  // The Rear Lower Hook (0872/C/11): a Xtru
  TGeoXtru *rearLwHookShape = new TGeoXtru(2);
  rearLwHookShape->SetName("ITSrearLwHookShape");

  xprof[0] = kRearLwHookWide/2;
  yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
  xprof[1] = xprof[0];
  alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
  yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
  xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
  yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
  xprof[3] = 0;
  yprof[3] = kRearLwHookRext;

  // We did the right side, now reflex on the left side
  for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
    xprof[4+jp] = -xprof[2-jp];
    yprof[4+jp] =  yprof[2-jp];
  }

  // Now the actual Xtru
  rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
  rearLwHookShape->DefineSection(0, 0);
  rearLwHookShape->DefineSection(1, kRearLwHookThick);

  // The Rear Lower Bracket (0872/C/16): a Xtru
  TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
  rearLwBrackShape->SetName("ITSrearLwBrackShape");

  xprof[0] = 0;
  yprof[0] = 0;
  xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[0] + kRearLwBracketHi2;
  xprof[3] = xprof[2] - kRearLwBracketWide1;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] - kRearLwBracketHi1;
  xprof[5] = xprof[0];
  yprof[5] = yprof[4];

  rearLwBrackShape->DefinePolygon(6, xprof, yprof);
  rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
  rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);

  // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
  TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);

  xprof[0] = 0;
  yprof[0] = 0;
  xprof[1] = xprof[0] + kForwWebSStirrLen1;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kForwWebSStirrWide1;
  xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] + kForwWebSStirrWide3;
  xprof[5] = xprof[4] - kForwWebSStirrLen3;
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = yprof[0] + kForwWebSStirrWide2;
  xprof[7] = xprof[0];
  yprof[7] = yprof[6];

  forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
  forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
  forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);

  // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
  TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);

  xprof[0] = -kForwWebTStirrWide2/2;
  yprof[0] = 0;
  xprof[1] = -kForwWebTStirrWide1/2;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] - kForwWebTStirrLen1;
  xprof[3] =-xprof[2];
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[1];
  xprof[5] =-xprof[0];
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
  xprof[7] = xprof[0];
  yprof[7] = yprof[6];

  forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
  forwWebTStirr3Sh->DefineSection(0, 0);
  forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);

  TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);

  yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
  yprof[7] = yprof[6];

  forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
  forwWebTStirr4Sh->DefineSection(0, 0);
  forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);

  // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
  TGeoXtru *frWebClampSh = new TGeoXtru(2);

  xprof[0] = kFRWebClampIntWide/2;
  yprof[0] = kFRWebClampIntHi;
  xprof[1] = xprof[0];
  yprof[1] = 0;
  xprof[2] = kFRWebClampExtWide/2;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = kFRWebClampExtHi;
  for (Int_t jp = 0; jp < 4; jp++) {
    xprof[4+jp] = -xprof[3-jp];
    yprof[4+jp] =  yprof[3-jp];
  }

  frWebClampSh->DefinePolygon(8, xprof, yprof);
  frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
  frWebClampSh->DefineSection(1, kFRWebClampThick/2);

  // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
  TGeoXtru *upWebStirrSh = new TGeoXtru(2);

  xprof[0] = 0;
  yprof[0] = 0;
  xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
  xprof[3] = xprof[2] - kRearUpWebStirrThick;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] - kRearUpWebStirrH1;
  xprof[5] = xprof[4] + kRearUpWebStirrWide;
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = yprof[5] + kRearUpWebStirrH2;
  xprof[7] = xprof[0];
  yprof[7] = yprof[6];

  upWebStirrSh->DefinePolygon(8, xprof, yprof);
  upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
  upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);

  // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
  TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
					  kRearUpWebBarHi/2,
					  kRearUpWebBarThick/2);

  // The Webcam: a BBox
  TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
				       kWebcamLength/2,
				       kFRWebClampIntHi/2);

  // The Upper Wheel Slide (0872/C/Z/00-01-02)
  // A mother volume of air (to avoid assembly) contains the Alluminum block
  // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
  // (a Pcon) (The wheels are approximated as part of the block itself)
  // The Air mother volume
  TGeoXtru *upSlideAirSh = new TGeoXtru(2);
  upSlideAirSh->SetName("ITSupperSlideAirShape");

  xprof[0] = 0;
  yprof[0] = 0;
  xprof[1] = xprof[0];
  yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
  xprof[2] = xprof[1] - kUpperSlideIntDepth;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] - kUpperSlideTotHeight;
  xprof[4] = xprof[3] + kUpperSlideTotDepth;
  yprof[4] = yprof[3];
  xprof[5] = xprof[4];
  yprof[5] = yprof[0];

  upSlideAirSh->DefinePolygon(6, xprof, yprof);
  upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
  upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);

  // The (filled) Aluminum block: a Xtru
  TGeoXtru *upSlideAluSh = new TGeoXtru(2);
  upSlideAluSh->SetName("ITSupperSlideAluShape");

  xprof[0] = upSlideAirSh->GetX(0);
  yprof[0] = upSlideAirSh->GetY(0);
  xprof[1] = upSlideAirSh->GetX(1);
  yprof[1] = upSlideAirSh->GetY(1);
  xprof[2] = xprof[1] - kUpperSlideStubDep;
  yprof[2] = yprof[1];
  xprof[3] = xprof[2];
  yprof[3] = yprof[2] - kUpperSlideStubHi;
  xprof[4] = upSlideAirSh->GetX(2);
  yprof[4] = yprof[3];
  xprof[5] = xprof[4];
  yprof[5] = yprof[4] - kUpperSlideBlockHi;
  xprof[6] = upSlideAirSh->GetX(5);
  yprof[6] = yprof[5];
  xprof[7] = xprof[6];
  yprof[7] = yprof[0];

  upSlideAluSh->DefinePolygon(8, xprof, yprof);
  upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
  upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));

  // The cylindrical hole in the block; a Pcon
  TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
  upSlideHoleSh->SetName("ITSupperSlideHoleShape");

  zpos = upSlideAluSh->GetY(5);
  upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
  zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
	- 2*kUpperSlideHoleH1);
  upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
  upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
  zpos += kUpperSlideHoleH3;
  upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
  upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
  zpos += kUpperSlideHoleH1;
  upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
  upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
  zpos += kUpperSlideHoleH2;
  upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
  upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
  zpos += kUpperSlideHoleH1;
  upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);

  TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
				   new TGeoRotation("",0,-90,0) );
  upSlideHolePos->SetName("ITSupperSlideHolePos");
  upSlideHolePos->RegisterYourself();

  // The actual block: a CompositeShape
  TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");

  // The Steel pin in the block; a Pcon
  TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
  upSlidePinSh->SetName("ITSupperSlidePinShape");

  zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
       + kUpperSlidePinH3 - kUpperSlideBlockHi);
  upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
  zpos += kUpperSlidePinH3;
  upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
  upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
  zpos += kUpperSlidePinH2;
  upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
  upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
  zpos += kUpperSlidePinH1;
  upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);

  // The Lower Wheel Slide (0872/C/W/00-01-02-03)
  // A mother volume of air (to avoid assembly) contains the Alluminum block
  // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
  // (a Xtru) and the Steel pin (a Pcon)
  // (The wheels are approximated as part of the block itself)
  // The Air mother volume
  TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
  lwSlideAirSh->SetName("ITSlowerSlideAirShape");

  xprof[0] = 0;
  yprof[0] = 0;
  xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
  xprof[3] = xprof[2] - kLowerSlideTotDepth;
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
  xprof[5] = xprof[0];
  yprof[5] = yprof[4];

  lwSlideAirSh->DefinePolygon(6, xprof, yprof);
  lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
  lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);

  // The (filled) Aluminum block: a Xtru
  TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
  lwSlideAluSh->SetName("ITSlowerSlideAluShape");

  xprof[0] = lwSlideAirSh->GetX(0);
  yprof[0] = lwSlideAirSh->GetY(0);
  xprof[1] = lwSlideAirSh->GetX(1);
  yprof[1] = lwSlideAirSh->GetY(1);
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] - kLowerSlideBlockHi;
  xprof[3] = lwSlideAirSh->GetX(3);
  yprof[3] = yprof[2];
  xprof[4] = xprof[3];
  yprof[4] = yprof[3] + kLowerSlideBlockHi;
  xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
  yprof[5] = yprof[4];
  xprof[6] = xprof[5];
  yprof[6] = lwSlideAirSh->GetY(4);
  xprof[7] = xprof[0];
  yprof[7] = yprof[6];

  lwSlideAluSh->DefinePolygon(8, xprof, yprof);
  lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
  lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));

  // The cylindrical hole in the block; a Pcon
  TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
  lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");

  zpos = lwSlideAluSh->GetY(2);
  lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
  zpos += kLowerSlideHoleH1;
  lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
  lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
  zpos = lwSlideAluSh->GetY(4);
  lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);

  TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
						      0, 0,
				   new TGeoRotation("",0,-90,0) );
  lwSlideHolePos->SetName("ITSlowerSlideHolePos");
  lwSlideHolePos->RegisterYourself();

  // The actual block: a CompositeShape
  TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");

  // The Aluminum nose: a Xtru
  TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
  lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");

  xprof[0] = lwSlideAluSh->GetX(5);
  yprof[0] = lwSlideAluSh->GetY(5);
  xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
  yprof[1] = yprof[0];
  xprof[2] = xprof[1];
  yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
  xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
  yprof[3] = lwSlideAluSh->GetY(6);
  xprof[4] = xprof[0];
  yprof[4] = yprof[3];

  lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
  lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
  lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);

  // The Steel pin in the block; a Pcon
  TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
  lwSlidePinSh->SetName("ITSlowerSlidePinShape");

  zpos = lwSlideAirSh->GetY(2);
  lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
  zpos += kLowerSlidePinH2;
  lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
  lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
  zpos += kLowerSlidePinH1;
  lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);

  // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
  // to approximate arcs with polylines
  TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);

  for (Int_t j=0; j<11; j++) { // The internal arc
    xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
    yprof[j] = kStirrC12R50*SinD(90*j/10);
  }

  xprof[11] = xprof[10] + kStirrC12TailLen;
  yprof[11] = yprof[10];
  xprof[12] = xprof[11];
  yprof[12] = kStirrC12BodyHalfHi;
  xprof[13] = xprof[12] - kStirrC12BodyLen;
  yprof[13] = yprof[12];

  xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
  yprof[17] = kStirrC12HeadHalfHi;
  IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
		  kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
		  xprof[16], yprof[16], xdummy, ydummy);
  alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
  xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
  yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
  xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
  yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));

  xprof[18] = xprof[17] - kStirrC12HeadLen;
  yprof[18] = yprof[17];
  xprof[19] = xprof[18];
  yprof[19] = kStirrC12HeadIntHi;
  xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
  yprof[20] = yprof[19];
  for (Int_t j=1; j<4; j++) {
    xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
    yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
  }

  // We did the up side, now reflex on the bottom side
  for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
    xprof[24+jp] =  xprof[23-jp];
    yprof[24+jp] = -yprof[23-jp];
  }

  // Now the actual Xtru
  stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
  stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
  stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);

  // The first element of the Stirrup on the Forward side (0872/C/05):
  // a really complex Xtru (equal to part of the Muon Stirrup)
  // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
  TGeoXtru *stirrupC5Sh = new TGeoXtru(2);

  for (Int_t j=0; j<13; j++) { // The internal arc and the tail
    xprof[j] = stirrupC1C2Sh->GetX(j);
    yprof[j] = stirrupC1C2Sh->GetY(j);
  }

  xprof[13] = xprof[12] - kStirrC5BodyLen;
  yprof[13] = yprof[12];

  // We did the up side, now reflex on the bottom side
  for (Int_t jp = 0; jp < 13; jp++) {
    xprof[14+jp] =  xprof[13-jp];
    yprof[14+jp] = -yprof[13-jp];
  }

  // Now the actual Xtru
  stirrupC5Sh->DefinePolygon(27, xprof, yprof);
  stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
  stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAlcoa   = mgr->GetMedium("ITS_ALUMINUM$"); // To code!!!!!!
  TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
  TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
  TGeoMedium *medErgal   = mgr->GetMedium("ITS_ERGAL$");
  TGeoMedium *medAisi    = mgr->GetMedium("ITS_AISI304L$");
  TGeoMedium *medAir     = mgr->GetMedium("ITS_AIR$");
  TGeoMedium *medPlexy   = mgr->GetMedium("ITS_PLEXYGLAS$");
  TGeoMedium *medPVC     = mgr->GetMedium("ITS_PVC$");


  TGeoVolume *suppRingC2C3  = new TGeoVolume("ITSTPCsupportRingC2C3",
					     ringC2C3, medAlcoa);

  suppRingC2C3->SetVisibility(kTRUE);
  suppRingC2C3->SetLineColor(6); // Purple
  suppRingC2C3->SetLineWidth(1);
  suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
  suppRingC2C3->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwUpHook  = new TGeoVolume("ITSTPCsupportForwUpHook",
					   forwUpHookShape, medHokotol);

  forwUpHook->SetVisibility(kTRUE);
  forwUpHook->SetLineColor(6); // Purple
  forwUpHook->SetLineWidth(1);
  forwUpHook->SetFillColor(forwUpHook->GetLineColor());
  forwUpHook->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwLwHook  = new TGeoVolume("ITSTPCsupportForwLwHook",
					   forwLwHookShape, medHokotol);

  forwLwHook->SetVisibility(kTRUE);
  forwLwHook->SetLineColor(6); // Purple
  forwLwHook->SetLineWidth(1);
  forwLwHook->SetFillColor(forwLwHook->GetLineColor());
  forwLwHook->SetFillStyle(4000); // 0% transparent

  TGeoVolume *rearUpHook  = new TGeoVolume("ITSTPCsupportRearUpHook",
					   rearUpHookShape, medHokotol);

  rearUpHook->SetVisibility(kTRUE);
  rearUpHook->SetLineColor(6); // Purple
  rearUpHook->SetLineWidth(1);
  rearUpHook->SetFillColor(rearUpHook->GetLineColor());
  rearUpHook->SetFillStyle(4000); // 0% transparent

  TGeoVolume *rearLwHook  = new TGeoVolume("ITSTPCsupportRearLwHook",
					   rearLwHookShape, medAnticor);

  rearLwHook->SetVisibility(kTRUE);
  rearLwHook->SetLineColor(6); // Purple
  rearLwHook->SetLineWidth(1);
  rearLwHook->SetFillColor(rearLwHook->GetLineColor());
  rearLwHook->SetFillStyle(4000); // 0% transparent

  TGeoVolume *rearLwBrack  = new TGeoVolume("ITSTPCsupportRearLwBracket",
					    rearLwBrackShape, medAnticor);

  rearLwBrack->SetVisibility(kTRUE);
  rearLwBrack->SetLineColor(6); // Purple
  rearLwBrack->SetLineWidth(1);
  rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
  rearLwBrack->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwWebSStirrup  = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
						forwWebSStirrSh, medAnticor);

  forwWebSStirrup->SetVisibility(kTRUE);
  forwWebSStirrup->SetLineColor(6); // Purple
  forwWebSStirrup->SetLineWidth(1);
  forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
  forwWebSStirrup->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwWebTStirr3  = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
					       forwWebTStirr3Sh, medAnticor);

  forwWebTStirr3->SetVisibility(kTRUE);
  forwWebTStirr3->SetLineColor(6); // Purple
  forwWebTStirr3->SetLineWidth(1);
  forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
  forwWebTStirr3->SetFillStyle(4000); // 0% transparent

  TGeoVolume *forwWebTStirr4  = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
					       forwWebTStirr4Sh, medAnticor);

  forwWebTStirr4->SetVisibility(kTRUE);
  forwWebTStirr4->SetLineColor(6); // Purple
  forwWebTStirr4->SetLineWidth(1);
  forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
  forwWebTStirr4->SetFillStyle(4000); // 0% transparent

  TGeoVolume *frWebClamp  = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
					   frWebClampSh, medPlexy);

  frWebClamp->SetVisibility(kTRUE);
  frWebClamp->SetLineColor(kAzure);
  frWebClamp->SetLineWidth(1);
  frWebClamp->SetFillColor(frWebClamp->GetLineColor());
  frWebClamp->SetFillStyle(4000); // 0% transparent

  TGeoVolume *upWebStirrup  = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
					     upWebStirrSh, medAnticor);

  upWebStirrup->SetVisibility(kTRUE);
  upWebStirrup->SetLineColor(6); // Purple
  upWebStirrup->SetLineWidth(1);
  upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
  upWebStirrup->SetFillStyle(4000); // 0% transparent

  TGeoVolume *upRearWebBar  = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
					     upRearWebBarSh, medPlexy);

  upRearWebBar->SetVisibility(kTRUE);
  upRearWebBar->SetLineColor(kAzure);
  upRearWebBar->SetLineWidth(1);
  upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
  upRearWebBar->SetFillStyle(4000); // 0% transparent

  TGeoVolume *webCam  = new TGeoVolume("ITSTPCsupportWebcam",
				       webcamShape, medPVC);

  webCam->SetVisibility(kTRUE);
  webCam->SetLineColor(kBlack);
  webCam->SetLineWidth(1);
  webCam->SetFillColor(webCam->GetLineColor());
  webCam->SetFillStyle(4000); // 0% transparent

  TGeoVolume *upSlideVol  = new TGeoVolume("ITSTPCsupportUpperSlide",
					   upSlideAirSh, medAir);

  upSlideVol->SetVisibility(kFALSE);

  TGeoVolume *upSlideBlock  = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
					     upSlideBlockSh, medAnticor);

  upSlideBlock->SetVisibility(kTRUE);
  upSlideBlock->SetLineColor(6); // Purple
  upSlideBlock->SetLineWidth(1);
  upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
  upSlideBlock->SetFillStyle(4000); // 0% transparent

  TGeoVolume *upSlidePin  = new TGeoVolume("ITSTPCsupportUpperSlidePin",
					   upSlidePinSh, medAisi);

  upSlidePin->SetVisibility(kTRUE);
  upSlidePin->SetLineColor(kGray);
  upSlidePin->SetLineWidth(1);
  upSlidePin->SetFillColor(upSlidePin->GetLineColor());
  upSlidePin->SetFillStyle(4000); // 0% transparent

  TGeoVolume *lwSlideVol  = new TGeoVolume("ITSTPCsupportLowerSlide",
					   lwSlideAirSh, medAir);

  lwSlideVol->SetVisibility(kFALSE);

  TGeoVolume *lwSlideBlock  = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
					     lwSlideBlockSh, medAnticor);

  lwSlideBlock->SetVisibility(kTRUE);
  lwSlideBlock->SetLineColor(6); // Purple
  lwSlideBlock->SetLineWidth(1);
  lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
  lwSlideBlock->SetFillStyle(4000); // 0% transparent

  TGeoVolume *lwSlideNose  = new TGeoVolume("ITSTPCsupportLowerSlideNose",
					    lwSlideNoseSh, medAnticor);

  lwSlideNose->SetVisibility(kTRUE);
  lwSlideNose->SetLineColor(6); // Purple
  lwSlideNose->SetLineWidth(1);
  lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
  lwSlideNose->SetFillStyle(4000); // 0% transparent

  TGeoVolume *lwSlidePin  = new TGeoVolume("ITSTPCsupportLowerSlidePin",
					   lwSlidePinSh, medAisi);

  lwSlidePin->SetVisibility(kTRUE);
  lwSlidePin->SetLineColor(kGray);
  lwSlidePin->SetLineWidth(1);
  lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
  lwSlidePin->SetFillStyle(4000); // 0% transparent

  TGeoVolume *stirrC1C2  = new TGeoVolume("ITSTPCsupportStirrupC1C2",
					  stirrupC1C2Sh, medErgal);

  stirrC1C2->SetVisibility(kTRUE);
  stirrC1C2->SetLineColor(6); // Purple
  stirrC1C2->SetLineWidth(1);
  stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
  stirrC1C2->SetFillStyle(4000); // 0% transparent

  TGeoVolume *stirrC5  = new TGeoVolume("ITSTPCsupportStirrupC5",
					stirrupC5Sh, medErgal);

  stirrC5->SetVisibility(kTRUE);
  stirrC5->SetLineColor(6); // Purple
  stirrC5->SetLineWidth(1);
  stirrC5->SetFillColor(stirrC5->GetLineColor());
  stirrC5->SetFillStyle(4000); // 0% transparent


  // Build up the wheel slides
  upSlideVol->AddNode(upSlideBlock,1,0);
  upSlideVol->AddNode(upSlidePin,  1,
		      new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
					 new TGeoRotation("",0,-90,0) ) );

  lwSlideVol->AddNode(lwSlideBlock,1,0);
  lwSlideVol->AddNode(lwSlideNose ,1,0);
  lwSlideVol->AddNode(lwSlidePin,  1,
		      new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
					 new TGeoRotation("",0,-90,0) ) );


  // Finally put everything in the mother volume
  moth->AddNode(suppRingC2C3,1,
		new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
  moth->AddNode(suppRingC2C3,2,
		new TGeoCombiTrans( 0, 0,-kRingCZPos,
				   new TGeoRotation("",0.,180.,0.) ) );
  moth->AddNode(suppRingC2C3,3,
		new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
				   new TGeoRotation("",0.,0.,180.) ) );
  moth->AddNode(suppRingC2C3,4,
		new TGeoCombiTrans( 0, 0,-kRingCZPos,
				   new TGeoRotation("",0.,180.,180.) ) );

  zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
  moth->AddNode(forwUpHook,1,
		new TGeoTranslation( 0, 0, zpos) );

  zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
  moth->AddNode(forwLwHook,1,
		new TGeoCombiTrans( 0, 0, zpos,
				   new TGeoRotation("",0.,0.,180.) ) );

  zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
  moth->AddNode(rearUpHook,1,
		new TGeoTranslation( 0, 0,-zpos) );

  zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
  moth->AddNode(rearLwHook,1,
		new TGeoCombiTrans( 0, 0,-zpos,
				   new TGeoRotation("",0.,0.,180.) ) );

  xpos =  kRearLwHookWide/2 + kRearLwBracketThick/2;
  ypos = -kRingCHeight;
  moth->AddNode(rearLwBrack,1,
		new TGeoCombiTrans( xpos, ypos,-zpos,
				   new TGeoRotation("", 90.,-90.,-90.) ) );
  moth->AddNode(rearLwBrack,2,
		new TGeoCombiTrans(-xpos, ypos,-zpos,
				   new TGeoRotation("", 90.,-90.,-90.) ) );

  xpos = kForwUpHookWide/2;
  ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
  zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
  moth->AddNode(forwWebSStirrup,1,
		new TGeoCombiTrans( xpos, ypos, zpos,
				   new TGeoRotation("", 0., 90., 0.) ) );
  xpos = kForwLwHookWide/2;
  ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
  moth->AddNode(forwWebSStirrup,2,
		new TGeoCombiTrans( xpos,-ypos, zpos,
				   new TGeoRotation("", 0., 90., 0.) ) );

  xpos = kForwUpHookWide/2
	+ (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
  ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
	+  forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
  zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
  moth->AddNode(forwWebTStirr3,1,
		new TGeoTranslation( xpos, ypos, zpos) );

  ypos -= frWebClampSh->GetZ(1);
  moth->AddNode(frWebClamp,1,
		new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
				   new TGeoRotation("", 0., 90., 0.) ) );

  ypos -= webcamShape->GetDY()/2;
  moth->AddNode(webCam,1,
		new TGeoTranslation( xpos, ypos,
		     zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );

  xpos = kForwLwHookWide/2
	+ (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
  ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
	+  forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
  moth->AddNode(forwWebTStirr4,1,
		new TGeoCombiTrans( xpos,-ypos, zpos,
				   new TGeoRotation("", 180., 0., 0.) ) );

  ypos -= frWebClampSh->GetZ(1);
  moth->AddNode(frWebClamp,2,
		new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
				   new TGeoRotation("", 0., 90., 0.) ) );

  ypos -= webcamShape->GetDY()/2;
  moth->AddNode(webCam,2,
		new TGeoTranslation( xpos,-ypos,
		     zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );

  xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
  ypos = kRingCHeight;
  zpos = kRingCZPos + kRingCThick;
  moth->AddNode(upWebStirrup,1,
		new TGeoCombiTrans( xpos, ypos,-zpos,
				   new TGeoRotation("",-90.,-90., 90.) ) );
  moth->AddNode(upWebStirrup,2,
		new TGeoCombiTrans(-xpos, ypos,-zpos,
				   new TGeoRotation("",-90.,-90., 90.) ) );

  ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
  zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
       - upRearWebBarSh->GetDZ();
  moth->AddNode(upRearWebBar,1,
		new TGeoTranslation( 0, ypos,-zpos) );

  zpos -= upRearWebBarSh->GetDZ();
  moth->AddNode(frWebClamp,3,
		new TGeoCombiTrans( 0, ypos,-zpos,
				   new TGeoRotation("", 0., 90., 0.) ) );

  ypos -= webcamShape->GetDY()/2;
  zpos -= webcamShape->GetDZ();
  moth->AddNode(webCam,3,
		new TGeoTranslation( 0, ypos,-zpos) );

  xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
  ypos = ringC2C3->GetY(14);
  zpos = kRingCZPos + kRingCThick;
  moth->AddNode(upSlideVol,1,
		new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
				   new TGeoRotation("",-90.,-90., 90.) ) );
  moth->AddNode(upSlideVol,2,
		new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
				   new TGeoRotation("",-90.,-90., 90.) ) );
  moth->AddNode(upSlideVol,3,
		new TGeoCombiTrans( xpos, ypos, -zpos,
				   new TGeoRotation("", 90.,-90.,-90.) ) );
  moth->AddNode(upSlideVol,4,
		new TGeoCombiTrans(-xpos, ypos, -zpos,
				   new TGeoRotation("", 90.,-90.,-90.) ) );

  moth->AddNode(lwSlideVol,1,
		new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
				   new TGeoRotation("", 90.,-90., 90.) ) );
  moth->AddNode(lwSlideVol,2,
		new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
				   new TGeoRotation("", 90.,-90., 90.) ) );
  moth->AddNode(lwSlideVol,3,
		new TGeoCombiTrans( xpos,-ypos,-zpos,
				   new TGeoRotation("",-90.,-90.,-90.) ) );
  moth->AddNode(lwSlideVol,4,
		new TGeoCombiTrans(-xpos,-ypos,-zpos,
				   new TGeoRotation("",-90.,-90.,-90.) ) );

  xpos = kStirrCXPos;
  zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
  moth->AddNode(stirrC1C2,1,
		new TGeoTranslation( xpos, 0, zpos) );
  moth->AddNode(stirrC1C2,2,
		new TGeoCombiTrans(-xpos, 0, zpos,
				   new TGeoRotation("", 90.,-180.,-90.) ) );

  xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
  ypos = ringC2C3->GetY(14); // Slides are all at the same height
  zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
  moth->AddNode(upSlideVol,5,
		new TGeoCombiTrans( xpos, ypos, zpos,
				   new TGeoRotation("",-90.,-90., 90.) ) );
  moth->AddNode(upSlideVol,6,
		new TGeoCombiTrans(-xpos, ypos, zpos,
				   new TGeoRotation("",-90.,-90., 90.) ) );
  moth->AddNode(lwSlideVol,5,
		new TGeoCombiTrans( xpos,-ypos, zpos,
				   new TGeoRotation("", 90.,-90., 90.) ) );
  moth->AddNode(lwSlideVol,6,
		new TGeoCombiTrans(-xpos,-ypos, zpos,
				   new TGeoRotation("", 90.,-90., 90.) ) );

  xpos = kStirrCXPos;
  zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
  moth->AddNode(stirrC5,1,
		new TGeoTranslation( xpos, 0,-zpos) );
  moth->AddNode(stirrC5,2,
		new TGeoCombiTrans(-xpos, 0,-zpos,
				   new TGeoRotation("", 90.,-180.,-90.) ) );


  return;
}