Obsolete.
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySupport.cxx
index fb0a913..7eb1f4c 100644 (file)
@@ -97,8 +97,8 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr)
   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;
+  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;
@@ -478,7 +478,7 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr)
              -kHalfLengthRing));
 
   for (Int_t i=0; i<4; i++) {
-    Double_t thetaW = kThetaWing*(2*i+1);
+    Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
     vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
              kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
              +kHalfLengthRing, new TGeoRotation("",thetaW,0,0)  ));
@@ -741,6 +741,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
 //
 // Created:         ???       Bjorn S. Nilsen
 // Updated:      18 Feb 2008  Mario Sitta
+// Updated:      25 Jul 2008  Mario Sitta   SDDCarbonFiberCone simpler
 //
 // Technical data are taken from:  "Supporto Generale Settore SDD"
 // (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
@@ -767,7 +768,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   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 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;
@@ -891,7 +892,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
 
   dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
 
-  TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
+  TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
 
   coneshape->Z(0)     = 0.0;
   coneshape->Rmin(0)  = kConeROutMin;
@@ -920,52 +921,35 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
 
   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,0.0,kConeRinMax,90.0-kConeTheta,z,rmax);
+  RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
+                   90.0-kConeTheta,z,rmax);
+  coneshape->Z(8)     = z;
   coneshape->Rmax(8)  = rmax;
-  coneshape->Z(8)     = ZFromRmaxpCone(coneshape,4,kConeTheta,
-                                      coneshape->GetRmax(8));
 
   coneshape->Z(9)     = kConeZCylinder;
   coneshape->Rmin(9)  = kConeRinMin;
+  coneshape->Rmax(9)  = kConeRinCylinder;
 
-  coneshape->Z(10)    = coneshape->GetZ(9);
-  coneshape->Rmin(10) = kConeRinCylinder;
-
-  coneshape->Rmin(11) = kConeRinCylinder;
-  coneshape->Rmax(11) = coneshape->GetRmin(11);
-
-  rmin                = coneshape->GetRmin(8);
-  RadiusOfCurvature(kConeRCurv,90.0-kConeTheta,
-                   coneshape->GetZ(8),coneshape->GetRmax(8),90.0,z,rmax);
-  rmax                = kConeRinMax;
-  coneshape->Z(11)    = z + (coneshape->GetZ(8)-z)*
-                   (coneshape->GetRmax(11)-rmax)/(coneshape->GetRmax(8)-rmax);
-
-  coneshape->Rmax(9)  = RmaxFrom2Points(coneshape,11,8,coneshape->GetZ(9));
-
-  coneshape->Rmax(10) = coneshape->GetRmax(9);
-
-  coneshape->Z(6)     = z - kConeDZin;
-  coneshape->Z(7)     = coneshape->GetZ(6);
-
-  coneshape->Rmax(6)  = RmaxFromZpCone(coneshape,4,kConeTheta,
-                                      coneshape->GetZ(6));
-
-  coneshape->Rmax(7)  = coneshape->GetRmax(6);
-
-  RadiusOfCurvature(kConeRCurv,90.,
-                   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;
 
   // SDD Cone Insert: another Pcon
   Double_t x0, y0, x1, y1, x2, y2;
@@ -1076,54 +1060,155 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   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(coneshape,3,kConeTheta,
+  hole1shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
                                       hole1shape->GetRmin(0));
 
   hole1shape->Rmax(1) = hole1shape->GetRmax(0);
-  hole1shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
+  hole1shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
                                       hole1shape->GetRmax(1));
-  hole1shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+  hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
                                       hole1shape->GetZ(1));
 
   hole1shape->Rmin(2) = kHole1RMin;
-  hole1shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
+  hole1shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
                                       hole1shape->GetRmin(2));
-  hole1shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+  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(coneshape,4,kConeTheta,
+  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(coneshape,3,kConeTheta,
+  hole2shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
                                       hole2shape->GetRmin(0));
 
   hole2shape->Rmax(1) = hole2shape->GetRmax(0);
-  hole2shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
+  hole2shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
                                       hole2shape->GetRmax(1));
-  hole2shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+  hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
                                       hole2shape->GetZ(1));
 
   hole2shape->Rmin(2) = kHole2RMin;
-  hole2shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
+  hole2shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
                                       hole2shape->GetRmin(2));
-  hole2shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+  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(coneshape,4,kConeTheta,
+  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();
 
@@ -1131,26 +1216,75 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
 
   hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
   hole3shape->Rmax(0) = hole3shape->GetRmin(0);
-  hole3shape->Z(0)    = ZFromRminpCone(coneshape,3,kConeTheta,
+  hole3shape->Z(0)    = ZFromRminpCone(conefoamshape,0,kConeTheta,
                                       hole3shape->GetRmin(0));
 
   hole3shape->Rmax(1) = hole3shape->GetRmax(0);
-  hole3shape->Z(1)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
+  hole3shape->Z(1)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
                                       hole3shape->GetRmax(1));
-  hole3shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+  hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
                                       hole3shape->GetZ(1));
 
   hole3shape->Rmin(2) = kHole3RMin;
-  hole3shape->Z(2)    = ZFromRminpCone(coneshape,3,kConeTheta,
+  hole3shape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
                                       hole3shape->GetRmin(2));
-  hole3shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+  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(coneshape,4,kConeTheta,
+  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);
@@ -1184,6 +1318,8 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
     conefoamshape->InspectShape();
     hole1shape->InspectShape();
     hole2shape->InspectShape();
+    hole3shape->InspectShape();
+    hole4shape->InspectShape();
   }
 
 
@@ -1221,6 +1357,22 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   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 *hole2 = new TGeoVolume("SDDCableHole2",
                                     hole2shape,medSDDair);
   hole2->SetVisibility(kTRUE);
@@ -1229,6 +1381,22 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   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 *hole3 = new TGeoVolume("SDDCableHole3",
                                     hole3shape,medSDDair);
   hole3->SetVisibility(kTRUE);
@@ -1237,6 +1405,22 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   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);
@@ -1248,23 +1432,30 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   // Mount up a cone
   cfconeinsert->AddNode(cfconefoam,1,0);
 
-  cfcone->AddNode(cfconeinsert,1,0);
-
   for (Int_t i=0; i<12; i++) {
     Double_t phiH = i*30.0;
-    cfcone->AddNode(hole1, i+1, new TGeoRotation("", 0, 0, phiH));
+    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;
-    cfcone->AddNode(hole2, i+1, new TGeoRotation("", 0, 0, phiH));
+    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;
-    cfcone->AddNode(hole3, i+1, new TGeoRotation("", phiH, 0, 0));
+    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;
@@ -1326,7 +1517,7 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
   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      = ( 593.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;
@@ -1337,7 +1528,7 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
   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.0 *fgkDegree; // Cone angle
+  const Double_t kConeTheta            =       39.1 *fgkDegree; // Cone angle
   const Double_t kSinConeTheta         =
                                       TMath::Sin(kConeTheta*TMath::DegToRad());
   const Double_t kCosConeTheta         =
@@ -1364,7 +1555,7 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
   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          = ( 540.0/2) *fgkmm;// See SDD ROutMin
+  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;
@@ -1682,6 +1873,9 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
                                           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();
 
@@ -1689,30 +1883,71 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
 
   coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
   coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
-  coolingholeshape->Z(0)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+  coolingholeshape->Z(0)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
                                             coolingholeshape->GetRmin(0));
 
   coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
-  coolingholeshape->Z(1)    = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
+  coolingholeshape->Z(1)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
                                             coolingholeshape->GetRmax(1));
-  coolingholeshape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
+  coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
                                             coolingholeshape->GetZ(1));
 
   coolingholeshape->Rmin(2) = kCoolingHoleRmin;
-  coolingholeshape->Z(2)    = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+  coolingholeshape->Z(2)    = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
                                             coolingholeshape->GetRmin(2));
-  coolingholeshape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
+  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(coneshape,7,90.-kConeTheta,
+  coolingholeshape->Z(3)    = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
                                             coolingholeshape->GetRmax(3));
 
-  // This is really weird: a single mountinghole volume gives an overlap
-  // with coneinsert (why doesn't coolinghole ?), so three contiguous
-  // volumes are created: one to be put in coneinsert and two in the cone
-  // carbon fiber envelope
+  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);
@@ -1868,6 +2103,22 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
   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);
@@ -1929,6 +2180,11 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
     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);
 
@@ -1936,7 +2192,8 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
 
   for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
     Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
-    cfcone->AddNode(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
+    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));
   }
 
@@ -1958,7 +2215,7 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
   }
 
   Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
-                      bracketshape->GetDz();
+                      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,
@@ -2542,7 +2799,7 @@ void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
     } // end for i
     if(GetDebug(1)) for(i=0;i<kct24Ntrays;i++) Info("ServicesCableSupport",
                                                   "tha[%d]=%f",i,tha[i]);
-    Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
+    const Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
                                   "TV00","SDD1","SDD2","SPD2","SPD3","ALG0",
                                   "SPD4","SPD5","SSD2","SSD3","SPD6","SPD7",
                                   "TV01","SDD3","SDD4","SPD8","SPD9","ALG1",
@@ -2550,7 +2807,7 @@ void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
                                   "TV02","SDD6","SDD7","SPDC","SPDD","ALG2",
                                   "SPDE","SPDF","SSD6","SSD7","SPDG","SPDH",
                                   "TV03","SDD8","SDD9","SPDI","SPDJ","ALG3"};
-    Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
+    const Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
                                    "TV00","SDD0","SDD1","SDD2","SPD1","ALG0",
                                    "SPD2","SSD4","SSD5","SSD6","SSD7","SPD3",
                                    "TV01","SDD3","SDD4","SDD5","SPD4","ALG1",
@@ -2622,7 +2879,7 @@ void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
         thb[i+  kft24NPatchPannels/2] = 180.0 + thb[i];
         thb[i+3*kft24NPatchPannels/4] = 270.0 + thb[i];
     } // end for i
-    Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
+    const Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
                                           "SPD2","SSD1","SPD3","SDD1","SPD4",
                                           "FMD1","SSD2","SPD5","SDD2","SPD6",
                                           "SPD7","SSD3","SPD8","SDD3","SPD9"};