Merge branch 'master' into TPCdev
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySPD.cxx
index e7cd058..d758530 100644 (file)
@@ -79,6 +79,8 @@
 #include <TGeoVolume.h>
 #include <TGeoXtru.h>
 #include <TGeoPcon.h>
+#include <TGeoPgon.h>
+#include <TGeoArb8.h>
 
 // AliRoot includes
 #include "AliLog.h"
@@ -87,6 +89,7 @@
 
 // Declaration file
 #include "AliITSv11GeometrySPD.h"
+#include "AliITSv11GeomCableRound.h"
 
 // Constant definistions
 const Double_t AliITSv11GeometrySPD::fgkGapLadder    =
@@ -94,6 +97,9 @@ const Double_t AliITSv11GeometrySPD::fgkGapLadder    =
 const Double_t AliITSv11GeometrySPD::fgkGapHalfStave =
                      AliITSv11Geometry::fgkmicron*120.; // 120 microns
 
+using std::endl;
+using std::cout;
+using std::ios;
 ClassImp(AliITSv11GeometrySPD)
 //______________________________________________________________________
 AliITSv11GeometrySPD::AliITSv11GeometrySPD(/*Double_t gap*/):
@@ -213,7 +219,7 @@ AliITSv11GeometrySPD& AliITSv11GeometrySPD::operator=(const
 }
 //______________________________________________________________________
 TGeoMedium* AliITSv11GeometrySPD::GetMedium(const char* mediumName,
-                                            TGeoManager *mgr) const
+                                            const TGeoManager *mgr) const
 {
     //
     // This function is used to recovery any medium
@@ -223,7 +229,7 @@ TGeoMedium* AliITSv11GeometrySPD::GetMedium(const char* mediumName,
     //
      Char_t itsMediumName[30];
 
-     sprintf(itsMediumName, "ITS_%s", mediumName);
+     snprintf(itsMediumName, 30, "ITS_%s", mediumName);
      TGeoMedium* medium = mgr->GetMedium(itsMediumName);
      if (!medium) AliError(Form("Medium <%s> not found", mediumName));
 
@@ -361,6 +367,7 @@ void AliITSv11GeometrySPD::SPDSector(TGeoVolume *moth, TGeoManager *mgr)
     delete secRot;
 
     CreateCones(moth);
+    CreateServices(moth);
 }
 //______________________________________________________________________
 void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
@@ -406,7 +413,6 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     //TGeoMedium *medSPDal      = 0;//SPD support cone SDD mounting bracket Al
     TGeoMedium *medSPDcf     = GetMedium("SPD C (M55J)$", mgr);
     TGeoMedium *medSPDss     = GetMedium("INOX$", mgr);
-    TGeoMedium *medSPDair    = GetMedium("AIR$", mgr);
     TGeoMedium *medSPDcoolfl = GetMedium("Freon$", mgr); //ITSspdCoolingFluid
     //
     const Double_t ksecDz           =  0.5 * 500.0 * fgkmm;
@@ -592,6 +598,7 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     const Int_t ksecDipIndex[ksecNCoolingTubeDips] = {2, 5, 8, 11, 14, 17};
     Double_t secAngleStart[ksecNRadii];
     Double_t secAngleEnd[ksecNRadii];
+    for(Int_t i = 0; i < ksecNRadii; i++)secAngleEnd[i] = 0.;
     Double_t secAngleStart2[ksecNRadii];
     Double_t secAngleEnd2[ksecNRadii];
     Double_t secAngleTurbo[ksecNCoolingTubeDips] = {0., 0., 0., 0., 0., 0.0};
@@ -601,7 +608,8 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     Double_t  xpp2[ksecNPoints], ypp2[ksecNPoints];
     Double_t *xp[ksecNRadii],   *xp2[ksecNRadii];
     Double_t *yp[ksecNRadii],   *yp2[ksecNRadii];
-    TGeoXtru *sA0,  *sA1, *sB0, *sB1,*sB2;
+    TGeoXtru *sA0,  *sA1, *sB0, *sB1;
+    TGeoCompositeShape *sA2, *sB2;
     TGeoBBox *sB3;
     TGeoEltu *sTA0, *sTA1;
     TGeoTube *sTB0, *sTB1; //,*sM0;
@@ -763,7 +771,7 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
         } // end if GetDebug(3)
     } // end for i
     sA0 = new TGeoXtru(2);
-    sA0->SetName("ITS SPD Carbon fiber support Sector A0");
+    sA0->SetName("SectorA0");
     sA0->DefinePolygon(m, xpp, ypp);
     sA0->DefineSection(0, -ksecDz);
     sA0->DefineSection(1,  ksecDz);
@@ -823,10 +831,13 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
         } // end for k
     } // end for i
     sA1 = new TGeoXtru(2);
-    sA1->SetName("ITS SPD Carbon fiber support Sector Air A1");
+    sA1->SetName("SectorA1");
     sA1->DefinePolygon(m, xpp2, ypp2);
-    sA1->DefineSection(0, -ksecDz);
-    sA1->DefineSection(1,  ksecDz);
+    sA1->DefineSection(0, -ksecDz-ksecCthick2);
+    sA1->DefineSection(1,  ksecDz+ksecCthick2);
+
+    sA2 = new TGeoCompositeShape("ITS SPD Carbon fiber support Sector A0",
+                                "SectorA0-SectorA1");
     //
     // Error in TGeoEltu. Semi-axis X must be < Semi-axis Y (?).
     sTA0 = new TGeoEltu("ITS SPD Cooling Tube TA0", 0.5 * ksecCoolTubeFlatY,
@@ -837,7 +848,7 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     SPDsectorShape(ksecNRadii,secX2,secY2,secR2,secAngleStart2,secAngleEnd2,
                    ksecNPointsPerRadii, m, xp, yp);
     sB0 = new TGeoXtru(2);
-    sB0->SetName("ITS SPD Carbon fiber support Sector End B0");
+    sB0->SetName("EndB0");
     sB0->DefinePolygon(m, xpp, ypp);
     sB0->DefineSection(0, ksecDz);
     sB0->DefineSection(1, ksecDz + ksecZEndLen);
@@ -873,50 +884,40 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     InsidePoint(xpp[m-2],ypp[m-2],xpp[m-1],ypp[m-1],xpp[0],ypp[0],
                 ksecCthick2,xpp2[i2],ypp2[i2]);
     sB1 = new TGeoXtru(2);
-    sB1->SetName("ITS SPD Carbon fiber support Sector Air End B1");
+    sB1->SetName("EndB1");
     sB1->DefinePolygon(i2+1, xpp2, ypp2);
-    sB1->DefineSection(0,sB0->GetZ(0));
-    sB1->DefineSection(1,sB0->GetZ(1)-ksecCthick2);
-    const Double_t kspdEndHoleRadius1=5.698*fgkmm;
-    const Double_t kspdEndHoleRadius2=2.336*fgkmm;
-    const Double_t kspdEndHoleDisplacement=6.29*fgkmm;
-    k = (m-1)/4;
-    for(i=0;i<=k;i++){
-        t= ((Double_t)i)/((Double_t)(k));
-        if(!CFHolePoints(t,kspdEndHoleRadius1,kspdEndHoleRadius2,
-                         kspdEndHoleDisplacement,xpp2[i],ypp2[i])){
-            Warning("CarbonFiberSector","CFHolePoints failed "
-                    "i=%d m=%d k=%d t=%e",i,m,k,t);
-        } // end if
-        // simitry in each quadrant.
-        xpp2[2*k-i] = -xpp2[i];
-        ypp2[2*k-i] =  ypp2[i];
-        xpp2[2*k+i] = -xpp2[i];
-        ypp2[2*k+i] = -ypp2[i];
-        xpp2[4*k-i] =  xpp2[i];
-        ypp2[4*k-i] = -ypp2[i];
-    }// end for i
-    //xpp2[m-1] = xpp2[0]; // begining point in
-    //ypp2[m-1] = ypp2[0]; // comment with end point
-    sB2 = new TGeoXtru(2);
-    sB2->SetName("ITS SPD Hole in Carbon fiber support End plate");
-    sB2->DefinePolygon(4*k, xpp2, ypp2);
-    sB2->DefineSection(0,sB1->GetZ(1));
-    sB2->DefineSection(1,sB0->GetZ(1));
+    sB1->DefineSection(0,sB0->GetZ(0)-ksecCthick2);
+    sB1->DefineSection(1,sB0->GetZ(1)+ksecCthick2);
+
+    sB2 = new TGeoCompositeShape("ITS SPD Carbon fiber support Sector End B0",
+                                "EndB0-EndB1");
     // SPD sector mount blocks
     const Double_t kMountBlock[3] = {0.5*(1.8-0.2)*fgkmm,0.5*22.0*fgkmm,
                                      0.5*45.0*fgkmm};
     sB3 = new TGeoBBox((Double_t*)kMountBlock);
+    // SPD sector mount block screws and nuts (M.S. - 27 oct 2012)
+    const Double_t kMountBlockM3ScrewR = 0.5*3.0*fgkmm; // Metric screw
+    const Double_t kMountBlockHead1R   = 0.5*8.0*fgkmm;
+    const Double_t kMountBlockHead1H   = 1.0*fgkmm;
+    const Double_t kMountBlockHead2R   = 0.5*6.0*fgkmm;
+    const Double_t kMountBlockHead2H   = 2.7*fgkmm;
+    const Double_t kMountBlockM3NutR   = 1.8*kMountBlockM3ScrewR; // Metric nut
+    const Double_t kMountBlockM3NutH   = kMountBlockM3NutR; // Metric nut
+    TGeoTube *sM3 = new TGeoTube(0, kMountBlockM3ScrewR, sB3->GetDX());
+    TGeoTube *sD1 = new TGeoTube(0, kMountBlockHead1R,kMountBlockHead1H/2);
+    TGeoTube *sD2 = new TGeoTube(0, kMountBlockHead2R,kMountBlockHead2H/2);
+    TGeoPgon *sN3 = new TGeoPgon(0, 360, 6, 2);
+    sN3->DefineSection(0,-kMountBlockM3NutH/2, 0, kMountBlockM3NutR);
+    sN3->DefineSection(1, kMountBlockM3NutH/2, 0, kMountBlockM3NutR);
     // SPD sector cooling tubes
     sTB0 = new TGeoTube("ITS SPD Cooling Tube End TB0", 0.0,
-                   0.5*ksecCoolTubeROuter,0.5*(sB1->GetZ(1)-sB1->GetZ(0)));
+                   0.5*ksecCoolTubeROuter,0.5*(sB0->GetZ(1)-sB0->GetZ(0)));
     sTB1 = new TGeoTube("ITS SPD Cooling Tube End coolant TB0", 0.0,
                         sTB0->GetRmax() - ksecCoolTubeThick,sTB0->GetDz());
     //
     if(GetDebug(3)) {
         if(medSPDcf) medSPDcf->Dump(); else AliInfo("medSPDcf = 0");
         if(medSPDss) medSPDss->Dump(); else AliInfo("medSPDss = 0");
-        if(medSPDair) medSPDair->Dump(); else AliInfo("medSPDAir = 0");
         if(medSPDcoolfl) medSPDcoolfl->Dump();else AliInfo("medSPDcoolfl = 0");
         sA0->InspectShape();
         sA1->InspectShape();
@@ -931,19 +932,12 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     StavesInSector(vM0);
     // create other volumes with some graphical settings
     TGeoVolume *vA0 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorA0",
-                                     sA0, medSPDcf);
+                                     sA2, medSPDcf);
     vA0->SetVisibility(kTRUE);
     vA0->SetLineColor(4); // Blue
     vA0->SetLineWidth(1);
     vA0->SetFillColor(vA0->GetLineColor());
     vA0->SetFillStyle(4010); // 10% transparent
-    TGeoVolume *vA1 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorAirA1",
-                                     sA1, medSPDair);
-    vA1->SetVisibility(kTRUE);
-    vA1->SetLineColor(7); // light Blue
-    vA1->SetLineWidth(1);
-    vA1->SetFillColor(vA1->GetLineColor());
-    vA1->SetFillStyle(4090); // 90% transparent
     TGeoVolume *vTA0 = new TGeoVolume("ITSSPDCoolingTubeTA0", sTA0, medSPDss);
     vTA0->SetVisibility(kTRUE);
     vTA0->SetLineColor(15); // gray
@@ -958,33 +952,47 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     vTA1->SetFillColor(vTA1->GetLineColor());
     vTA1->SetFillStyle(4000); // 0% transparent
     TGeoVolume *vB0 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndB0",
-                                     sB0, medSPDcf);
+                                     sB2, medSPDcf);
     vB0->SetVisibility(kTRUE);
     vB0->SetLineColor(1); // Black
     vB0->SetLineWidth(1);
     vB0->SetFillColor(vB0->GetLineColor());
     vB0->SetFillStyle(4000); // 0% transparent
-    TGeoVolume *vB1 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndAirB1",
-                                     sB1, medSPDair);
-    vB1->SetVisibility(kTRUE);
-    vB1->SetLineColor(0); // white
-    vB1->SetLineWidth(1);
-    vB1->SetFillColor(vB1->GetLineColor());
-    vB1->SetFillStyle(4100); // 100% transparent
-    TGeoVolume *vB2 = new TGeoVolume("ITSSPDCarbonFiberSupportSectorEndAirB2",
-                                     sB2, medSPDair);
-    vB2->SetVisibility(kTRUE);
-    vB2->SetLineColor(0); // white
-    vB2->SetLineWidth(1);
-    vB2->SetFillColor(vB2->GetLineColor());
-    vB2->SetFillStyle(4100); // 100% transparent
     TGeoVolume *vB3 = new TGeoVolume(
         "ITSSPDCarbonFiberSupportSectorMountBlockB3",sB3, medSPDcf);
     vB3->SetVisibility(kTRUE);
-    vB3->SetLineColor(1); // Black
+    vB3->SetLineColor(26); // Brown shade
     vB3->SetLineWidth(1);
     vB3->SetFillColor(vB3->GetLineColor());
     vB3->SetFillStyle(4000); // 0% transparent
+    TGeoVolume *vM3 = new TGeoVolume(
+        "ITSSPDCarbonFiberSupportSectorMountBlockScrewM3",sM3, medSPDss);
+    vM3->SetVisibility(kTRUE);
+    vM3->SetLineColor(kGray); // Gray
+    vM3->SetLineWidth(1);
+    vM3->SetFillColor(vM3->GetLineColor());
+    vM3->SetFillStyle(4000); // 0% transparent
+    TGeoVolume *vD1 = new TGeoVolume(
+        "ITSSPDCarbonFiberSupportSectorMountBlockScrewHead1",sD1, medSPDss);
+    vD1->SetVisibility(kTRUE);
+    vD1->SetLineColor(kGray); // Gray
+    vD1->SetLineWidth(1);
+    vD1->SetFillColor(vD1->GetLineColor());
+    vD1->SetFillStyle(4000); // 0% transparent
+    TGeoVolume *vD2 = new TGeoVolume(
+        "ITSSPDCarbonFiberSupportSectorMountBlockScrewHead2",sD2, medSPDss);
+    vD2->SetVisibility(kTRUE);
+    vD2->SetLineColor(kGray); // Gray
+    vD2->SetLineWidth(1);
+    vD2->SetFillColor(vD2->GetLineColor());
+    vD2->SetFillStyle(4000); // 0% transparent
+    TGeoVolume *vN3 = new TGeoVolume(
+        "ITSSPDCarbonFiberSupportSectorMountBlockScrewNut",sN3, medSPDss);
+    vN3->SetVisibility(kTRUE);
+    vN3->SetLineColor(kGray); // Gray
+    vN3->SetLineWidth(1);
+    vN3->SetFillColor(vN3->GetLineColor());
+    vN3->SetFillStyle(4000); // 0% transparent
     TGeoVolume *vTB0 = new TGeoVolume("ITSSPDCoolingTubeEndTB0",sTB0,medSPDss);
     vTB0->SetVisibility(kTRUE);
     vTB0->SetLineColor(15); // gray
@@ -1001,9 +1009,6 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
 
     // add volumes to mother container passed as argument of this method
     moth->AddNode(vM0,1,0); // Add virtual volume to mother
-    vA0->AddNode(vA1,1,0); // Put air inside carbon fiber.
-    vB0->AddNode(vB1,1,0); // Put air inside carbon fiber ends.
-    vB0->AddNode(vB2,1,0); // Put air wholes inside carbon fiber ends
     vTA0->AddNode(vTA1,1,0); // Put cooling liquid indide tube middel.
     vTB0->AddNode(vTB1,1,0); // Put cooling liquid inside tube end.
     Double_t tubeEndLocal[3]={0.0,0.0,sTA0->GetDz()};
@@ -1011,10 +1016,13 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
         x0 = secX3[ksecDipIndex[i]];
         y0 = secY3[ksecDipIndex[i]];
         t = 90.0 - secAngleTurbo[i];
-        trans = new TGeoTranslation("",x0,y0,0.5*(sB1->GetZ(0)+sB1->GetZ(1)));
-        vB1->AddNode(vTB0, i+1, trans);
+       z0 = 0.5*(sB1->GetZ(0)+sB1->GetZ(1));
+        trans = new TGeoTranslation("",x0,y0,z0);
+        vM0->AddNode(vTB0, i+1, trans);
         // Find location of tube ends for later use.
         trans->LocalToMaster(tubeEndLocal,fTubeEndSector[0][0][i]);
+        trans = new TGeoTranslation("",x0,y0,-z0);
+        vM0->AddNode(vTB0, i+1+ksecNCoolingTubeDips, trans);
         rot = new TGeoRotation("", 0.0, 0.0, t);
         rotrans = new TGeoCombiTrans("", x0, y0, 0.0, rot);
         vM0->AddNode(vTA0, i+1, rotrans);
@@ -1027,6 +1035,22 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     // Find location of tube ends for later use.
     for(i=0;i<ksecNCoolingTubeDips;i++) rot->LocalToMaster(
                             fTubeEndSector[0][0][i],fTubeEndSector[0][1][i]);
+    // Put screws inside the mounting block
+    const Double_t kMountingBlockScrew1ZPos =  0.7 *fgkcm;
+    const Double_t kMountingBlockScrew2ZPos =  2.01*fgkcm;
+    const Double_t kMountingBlockScrew34Pos =  0.51*fgkcm;
+    vB3->AddNode(vM3, 1, new TGeoCombiTrans(0, 0,
+                                (sB3->GetDZ()-kMountingBlockScrew1ZPos),
+                                           new TGeoRotation("",90,90,90)));
+    vB3->AddNode(vM3, 2, new TGeoCombiTrans(0, 0,
+                                (sB3->GetDZ()-kMountingBlockScrew2ZPos),
+                                           new TGeoRotation("",90,90,90)));
+    vB3->AddNode(vM3, 3, new TGeoCombiTrans(0,-kMountingBlockScrew34Pos,
+                               -(sB3->GetDZ()-kMountingBlockScrew34Pos),
+                                           new TGeoRotation("",90,90,90)));
+    vB3->AddNode(vM3, 4, new TGeoCombiTrans(0, kMountingBlockScrew34Pos,
+                               -(sB3->GetDZ()-kMountingBlockScrew34Pos),
+                                           new TGeoRotation("",90,90,90)));
     // left side
     t = -TMath::RadToDeg()*TMath::ATan2(
                                    sB0->GetX(0)-sB0->GetX(sB0->GetNvert()-1),
@@ -1039,26 +1063,120 @@ void AliITSv11GeometrySPD::CarbonFiberSector(TGeoVolume *moth, Int_t sect,
     z0 = sB0->GetZ(0)+sB3->GetDZ();
     rotrans = new TGeoCombiTrans("",x0,y0,z0,rot);
     vM0->AddNode(vB3,1,rotrans); // Put Mounting bracket on sector
+    // the screw heads and nuts
+    Double_t h = sM3->GetDz() + sD1->GetDz();
+    Double_t zt = sB3->GetDZ()-kMountingBlockScrew1ZPos;
+    vM0->AddNode(vD1, 1, new TGeoCombiTrans(x0+h*CosD(180+t), y0+h*SinD(180+t),
+                                           z0+zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    h = sM3->GetDz() + sD2->GetDz() + ksecCthick2 + 0.06;
+    zt = sB3->GetDZ()-kMountingBlockScrew2ZPos;
+    vM0->AddNode(vD2, 1, new TGeoCombiTrans(x0+h*CosD(180+t), y0+h*SinD(180+t),
+                                           z0+zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    Double_t loc[3],mas[3];
+    loc[0]=0;
+    loc[1]=-kMountingBlockScrew34Pos;
+    loc[2]=-(sB3->GetDZ()-kMountingBlockScrew34Pos);
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vD2, 2, new TGeoCombiTrans(mas[0]+h*CosD(180+t),
+                                           mas[1]+h*SinD(180+t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vD2, 3, new TGeoCombiTrans(mas[0]+h*CosD(180+t),
+                                           mas[1]+h*SinD(180+t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+
+    rot = new TGeoRotation("",t,180.0,0.0);// z & x axis rotation
     rotrans = new TGeoCombiTrans("",x0,y0,-z0,rot);
     vM0->AddNode(vB3,2,rotrans); // Put Mounting bracket on sector
+    h = sM3->GetDz() + sN3->GetZ(1);
+    zt = sB3->GetDZ()-kMountingBlockScrew1ZPos;
+    vM0->AddNode(vN3, 1, new TGeoCombiTrans(x0+h*CosD(180+t), y0+h*SinD(180+t),
+                                          -z0-zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    h += ksecCthick2 + 0.06;
+    zt = sB3->GetDZ()-kMountingBlockScrew2ZPos;
+    vM0->AddNode(vN3, 2, new TGeoCombiTrans(x0+h*CosD(180+t), y0+h*SinD(180+t),
+                                          -z0-zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=-kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vN3, 3, new TGeoCombiTrans(mas[0]+h*CosD(180+t),
+                                           mas[1]+h*SinD(180+t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vN3, 4, new TGeoCombiTrans(mas[0]+h*CosD(180+t),
+                                           mas[1]+h*SinD(180+t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+
     t *= -1.0;
     rot = new TGeoRotation("",t,0.0,0.0); // z axis rotation
-  
     x0 = -0.5*(sB0->GetX(0)+sB0->GetX(sB0->GetNvert()-1))-3.5*
         sB3->GetDX()*TMath::Cos(t*TMath::DegToRad());
     y0 = 0.5*(sB0->GetY(0)+sB0->GetY(sB0->GetNvert()-1))-3.5*
         sB3->GetDX()*TMath::Sin(t*TMath::DegToRad());
-    rotrans = new TGeoCombiTrans("",1.01*x0,y0,z0,rot);
+    rotrans = new TGeoCombiTrans("",1.02*x0,y0,z0,rot);
     vM0->AddNode(vB3,3,rotrans); // Put Mounting bracket on sector
-    rotrans = new TGeoCombiTrans("",1.01*x0,y0,-z0,rot);
+    h = sM3->GetDz() + sN3->GetZ(1) + 0.03;
+    zt = sB3->GetDZ()-kMountingBlockScrew1ZPos;
+    vM0->AddNode(vN3, 5, new TGeoCombiTrans(x0-h*CosD(180-t), y0+h*SinD(180-t),
+                                           z0+zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    h += ksecCthick2 + 0.05;
+    zt = sB3->GetDZ()-kMountingBlockScrew2ZPos;
+    vM0->AddNode(vN3, 6, new TGeoCombiTrans(x0-h*CosD(180-t), y0+h*SinD(180-t),
+                                           z0+zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=-kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vN3, 7, new TGeoCombiTrans(mas[0]-h*CosD(180-t),
+                                           mas[1]+h*SinD(180-t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vN3, 8, new TGeoCombiTrans(mas[0]-h*CosD(180-t),
+                                           mas[1]+h*SinD(180-t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+
+    rot = new TGeoRotation("",t,180.0,0.0); // z & x axis rotation
+    rotrans = new TGeoCombiTrans("",1.02*x0,y0,-z0,rot);
     vM0->AddNode(vB3,4,rotrans); // Put Mounting bracket on sector
+    h = sM3->GetDz() + sD1->GetDz();
+    zt = sB3->GetDZ()-kMountingBlockScrew1ZPos;
+    vM0->AddNode(vD1, 2, new TGeoCombiTrans(x0-h*CosD(180-t), y0+h*SinD(180-t),
+                                          -z0-zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    h = sM3->GetDz() + sD2->GetDz() + ksecCthick2 + 0.08;
+    zt = sB3->GetDZ()-kMountingBlockScrew2ZPos;
+    vM0->AddNode(vD2, 4, new TGeoCombiTrans(x0-h*CosD(180-t), y0+h*SinD(180-t),
+                                          -z0-zt,
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=-kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vD2, 5, new TGeoCombiTrans(mas[0]-h*CosD(180-t),
+                                           mas[1]+h*SinD(180-t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+    loc[1]=kMountingBlockScrew34Pos;
+    rotrans->LocalToMaster(loc,mas);
+    vM0->AddNode(vD2, 6, new TGeoCombiTrans(mas[0]-h*CosD(180-t),
+                                           mas[1]+h*SinD(180-t),
+                                           mas[2],
+                                           new TGeoRotation("",90+t,90,90)));
+
     if(GetDebug(3)){
         vM0->PrintNodes();
         vA0->PrintNodes();
-        vA1->PrintNodes();
         vB0->PrintNodes();
-        vB1->PrintNodes();
-        vB2->PrintNodes();
         vB3->PrintNodes();
         vTA0->PrintNodes();
         vTA1->PrintNodes();
@@ -1606,16 +1724,16 @@ TGeoCompositeShape* AliITSv11GeometrySPD::CreateGroundingFoilShape
     } // end if itype==1
     switch (itype) {
     case 0:
-        sprintf(type,"Kap");
+        snprintf(type,10,"Kap");
         break;
     case 1:
-        sprintf(type,"Alu");
+        snprintf(type,10, "Alu");
         break;
     case 2:
-        sprintf(type,"Glue1");
+        snprintf(type,10,"Glue1");
         break;
     case 3:
-        sprintf(type,"Glue2");
+        snprintf(type,10,"Glue2");
         break;
     }
     // we divide the shape in several slices along the horizontal
@@ -1650,6 +1768,8 @@ TGeoCompositeShape* AliITSv11GeometrySPD::CreateGroundingFoilShape
     shGroundFull = new TGeoBBox(Form("ITSSPDSHgFoil%sFull", type),
                                 0.5*length,0.5*width, 0.5*thickness);
 
+    if(GetDebug(5)) shGroundFull->Print(); // Avoid Coverity warning
+
     // create the polygonal shape to be subtracted to give the correct
     // shape to the borders its vertices are defined in sugh a way that
     // this polygonal will be placed in the correct place considered
@@ -1741,9 +1861,8 @@ TGeoCompositeShape* AliITSv11GeometrySPD::CreateGroundingFoilShape
     Double_t holeY = 0.5*(width - holeWidth) - widthMin;
 
     // create a shape for the holes (common)
-    TGeoBBox *shHole = 0;
-    shHole = new TGeoBBox(Form("ITSSPD%sGfoilHole", type),0.5*holeLength,
-                          0.5*holeWidth, thickness);
+    new TGeoBBox(Form("ITSSPD%sGfoilHole", type),0.5*holeLength,
+                       0.5*holeWidth, thickness);
 
     // insert the holes in the XTRU shape:
     // starting from the first value of X, they are simply
@@ -1764,7 +1883,7 @@ TGeoCompositeShape* AliITSv11GeometrySPD::CreateGroundingFoilShape
             holeX += holeSepX2;
         } // end if else if's
         //cout << i << " --> X = " << holeX << endl;
-        sprintf(name,"ITSSPDTRgFoil%sHole%d", type, i);
+        snprintf(name,200,"ITSSPDTRgFoil%sHole%d", type, i);
         transHole[i] = new TGeoTranslation(name, holeX, holeY, 0.0);
         transHole[i]->RegisterYourself();
         strComposite.Append(Form("ITSSPD%sGfoilHole:%s", type, name));
@@ -1807,7 +1926,7 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateGroundingFoil(Bool_t isRight,
     // create a suffix to be used in the names of all shapes
     //
     char suf[5];
-    if (isRight) strcpy(suf, "R"); else strcpy(suf, "L");
+    if (isRight) strncpy(suf, "R", 5); else strncpy(suf, "L", 5);
     // this volume will be created in order to ease its placement in
     // the half-stave; then, it is added here the small distance of
     // the "central" edge of each volume from the Z=0 plane in the stave
@@ -1982,7 +2101,7 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreateMCM(Bool_t isRight,
 
     // to distinguish the "left" and "right" objects, a suffix is created
     char suf[5];
-    if (isRight) strcpy(suf, "R"); else strcpy(suf, "L");
+    if (isRight) strncpy(suf, "R", 5); else strncpy(suf, "L", 5);
 
     // ** MEDIA **
     TGeoMedium *medBase = GetMedium("SPD KAPTON(POLYCH2)$",mgr);// ??? MCM BASE
@@ -2288,6 +2407,9 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
     Double_t extThickness       = fgkmm * 0.25;
     Double_t ext1Length         = fgkmm * (26.7 - 10.0);
     Double_t ext2Length         = fgkmm * 284.0 - ext1Length + extThickness;
+    Double_t ext2LengthL2       = fgkmm * 130.0;
+    Double_t ext4Length         = fgkmm * 40.0;
+    Double_t ext4Twist          =  66.54; //deg
     Double_t extWidth           = fgkmm * 11.0;
     Double_t extHeight          = fgkmm * 2.5;
 
@@ -2366,12 +2488,14 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
                                    0.5*capWidth, 0.5*capLength);
 
     char extname[12];
-    sprintf(extname,"Extender1l%d",ilayer);
+    snprintf(extname,12,"Extender1l%d",ilayer);
     TGeoVolume *ext1 = mgr->MakeBox(extname, medExt, 0.5*extThickness, 0.5*extWidth, 0.5*ext1Length);
-    sprintf(extname,"Extender2l%d",ilayer);
+    snprintf(extname,12,"Extender2l%d",ilayer);
     TGeoVolume *ext2 = mgr->MakeBox(extname, medExt, 0.5*extHeight - 2.*extThickness, 0.5*extWidth, 0.5*extThickness);
     TGeoVolume *ext3=0;
-    sprintf(extname,"Extender3l%d",ilayer);
+    snprintf(extname,12,"Extender3l%d",ilayer);
+    TGeoVolume *ext4=0;
+    snprintf(extname,12,"Extender3l%d",ilayer);
     if (ilayer==1) {
       Double_t halflen=(0.5*ext2Length + extThickness);
       Double_t xprof[6],yprof[6];
@@ -2393,8 +2517,11 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
       ext3sh->DefineSection(0, -0.5*(extWidth-0.8*fgkmm));
       ext3sh->DefineSection(1,  0.5*(extWidth-0.8*fgkmm));
       ext3 = new TGeoVolume(extname, ext3sh, medExt);
-    } else
-      ext3 = mgr->MakeBox(extname, medExt, 0.5*extThickness, 0.5*(extWidth-0.8*fgkmm), 0.5*ext2Length + extThickness); // Hardcode fix of a small overlap
+    } else {
+      ext3 = mgr->MakeBox(extname, medExt, 0.5*extThickness, 0.5*(extWidth-0.8*fgkmm), 0.5*ext2LengthL2 + extThickness); // Hardcode fix of a small overlap
+      ext4= mgr->MakeGtra("Extender4l2", medExt, 0.5*ext4Length, 0, 0, ext4Twist, 0.5*(extWidth-0.8*fgkmm), 0.5*extThickness, 0.5*extThickness, 0, 0.5*(extWidth-0.8*fgkmm), 0.5*extThickness, 0.5*extThickness, 0);
+      ext4->SetLineColor(kGray);
+    }
     bus->SetLineColor(kYellow + 2);
     pt1000->SetLineColor(kGreen + 3);
     res->SetLineColor(kRed + 1);
@@ -2474,10 +2601,16 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
     x += 0.5*(extHeight - 3.*extThickness);
     TGeoTranslation *trExt2 = new TGeoTranslation(x, y, z);
     if (isRight) {
+      if (ilayer==1)
         z -= 0.5 * (ext2Length - extThickness) + 2.5*extThickness;
+      else
+        z -= 0.5 * (ext2LengthL2 - extThickness) + 2.5*extThickness;
     }
     else {
+      if (ilayer==1)
         z += 0.5 * (ext2Length - extThickness) + 2.5*extThickness;
+      else
+        z += 0.5 * (ext2LengthL2 - extThickness) + 2.5*extThickness;
     }
     x += 0.5*(extHeight - extThickness) - 2.*extThickness;
     TGeoCombiTrans *trExt3=0;
@@ -2491,7 +2624,17 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
     container->AddNode(ext1, 0, trExt1);
     container->AddNode(ext2, 0, trExt2);
     container->AddNode(ext3, 0, trExt3);
-
+    if (ilayer==2) {
+      TGeoCombiTrans *trExt4=0;
+      if (isRight) {
+       z -= ( ((TGeoBBox*)ext3->GetShape())->GetDZ() + ((TGeoGtra*)ext4->GetShape())->GetDZ() );
+       trExt4 = new TGeoCombiTrans(x, y, z, new TGeoRotation("", ext4Twist/2,0,0));
+      } else {
+       z += ( ((TGeoBBox*)ext3->GetShape())->GetDZ() + ((TGeoGtra*)ext4->GetShape())->GetDZ() );
+       trExt4 = new TGeoCombiTrans(x, y, z, new TGeoRotation("",-ext4Twist/2,0,0));
+      }
+      container->AddNode(ext4, 0, trExt4);
+    }
     sizes[3] = yRef + pt1000Y;
     sizes[4] = zRef + pt1000Z[2];
     sizes[5] = zRef + pt1000Z[7];
@@ -2574,7 +2717,7 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
     const Double_t kCollThickness   =  10.0  *fgkmm;
     const Double_t kCollTubeThick   =   1.0  *fgkmm;
     const Double_t kCollTubeRadius  =   7.0  *fgkmm;
-    const Double_t kCollTubeLength  = 190.0  *fgkmm;
+    const Double_t kCollTubeLength  = 205.0  *fgkmm;
 
     const Double_t kOptFibDiamet    =   4.5  *fgkmm;
 
@@ -2584,7 +2727,10 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
     Int_t kPurple = 6; // Purple (Root does not define it)
 
     TGeoVolumeAssembly* container[5];
-    container[0] = new TGeoVolumeAssembly("ITSSPDConeModule");
+    if (sideC)
+    container[0] = new TGeoVolumeAssembly("ITSSPDConeModuleC");
+    else
+    container[0] = new TGeoVolumeAssembly("ITSSPDConeModuleA");
     container[1] = new TGeoVolumeAssembly("ITSSPDCoolingModuleSideA");
     container[2] = new TGeoVolumeAssembly("ITSSPDCoolingModuleSideC");
     container[3] = new TGeoVolumeAssembly("ITSSPDPatchPanelModule");
@@ -2642,7 +2788,7 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
                                   0.5*cableW2,
                                   0.5*thickness);
     Char_t string[255];
-    sprintf(string, "%s-%s", shOut->GetName(), shIn->GetName());
+    snprintf(string, 255, "%s-%s", shOut->GetName(), shIn->GetName());
     TGeoCompositeShape *shPlate = new TGeoCompositeShape("ITSSPDPlate_shape",
                                 string);
 
@@ -2659,7 +2805,7 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
     volCollTube->SetLineColor(kAzure);
 
     // The cooling tube on the cone as a Ctub
-    Double_t tubeLength = shCable->GetX(5) - shCable->GetX(0) + kYtoHalfStave;
+    Double_t tubeLength = shCable->GetX(5) - shCable->GetX(0) + kYtoHalfStave -0.85;
     TGeoCtub *shTube = new TGeoCtub(0, kConeTubeRmax, 0.5*tubeLength, 0, 360,
                                    0, SinD(angrot/2), -CosD(angrot/2),
                                    0,              0,              1);
@@ -2714,7 +2860,7 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
     volCylGasFr->SetLineColor(kPurple);
 
     // The optical fibers bundle on the cone as a Tube
-    Double_t optLength = shCable->GetX(5) - shCable->GetX(0) + kYtoHalfStave;
+    Double_t optLength = shCable->GetX(5) - shCable->GetX(0) + kYtoHalfStave -0.85;
     TGeoTube *shOptFibs = new TGeoTube(0., 0.5*kOptFibDiamet, 0.5*optLength);
 
     TGeoVolume *volOptFibs = new TGeoVolume("ITSSPDOpticalFibersOnCone",
@@ -2809,7 +2955,7 @@ TList* AliITSv11GeometrySPD::CreateConeModule(Bool_t sideC, const Double_t angro
       container[0]->AddNode(volCollTube, 1, trCollTube);
     }
         
-    Double_t dxPatch = 2.9;
+    Double_t dxPatch = 2.75;
     Double_t dzPatch = 2.8;
     TGeoCombiTrans *tr2 = new TGeoCombiTrans(1.7*ext2Length - dxPatch, 0.0, dzPatch, rot2);
     container[3]->AddNode(volPatch, 0, tr2);
@@ -2885,7 +3031,7 @@ void AliITSv11GeometrySPD::CreateCones(TGeoVolume *moth) const
     const Int_t kNumberOfModules    =  10;
 
     const Double_t kInnerRadius     =  80.775*fgkmm;
-    const Double_t kZTrans          = 452.000*fgkmm;
+    const Double_t kZTrans          = 451.800*fgkmm;
     const Double_t kAlphaRot        =  46.500*fgkDegree;
     const Double_t kAlphaSpaceCool  =   9.200*fgkDegree;
 
@@ -3011,6 +3157,769 @@ void AliITSv11GeometrySPD::CreateCones(TGeoVolume *moth) const
 
 
 //______________________________________________________________________
+void AliITSv11GeometrySPD::CreateServices(TGeoVolume *moth) const
+{
+    //
+    // New method to implement SPD services
+    //
+    // Created:      25 Jul 2012  Mario Sitta
+    // Updated:      15 Nov 2012  Mario Sitta
+    //
+    // Data provided by C.Gargiulo from CAD
+
+    // Cooling manifolds
+    const Double_t kCoolManifWidth    = fgkmm * 22.0;
+    const Double_t kCoolManifLength   = fgkmm * 50.0;
+    const Double_t kCoolManifThick    = fgkmm *  7.0;
+    const Double_t kCoolManifFitR1out = fgkmm *  4.0;
+    const Double_t kCoolManifFitH1    = fgkmm *  2.5;
+    const Double_t kCoolManifFitR2out = fgkmm *  4.0;
+    const Double_t kCoolManifFitR2in  = fgkmm *  3.2;
+    const Double_t kCoolManifFitH2    = fgkmm *  7.0;
+    const Double_t kCoolManifFitZPos  = fgkmm *  2.0; // TO BE CHECKED!
+    const Double_t kCoolManifCollR1   = fgkmm *  3.0;
+    const Double_t kCoolManifCollH1   = fgkmm *  2.5;
+    const Double_t kCoolManifCollR2   = fgkmm *  1.5;
+    const Double_t kCoolManifCollH2   = fgkmm *  5.0;
+    const Double_t kCoolManifCollXPos = fgkmm *  5.0;
+    const Double_t kCoolManifCollDZ   = fgkmm * 13.0;
+    const Double_t kCoolManifCollZ0   = fgkmm *  9.0;
+
+    const Double_t kCoolManifRPosCAD  = fgkmm * 76.2;
+    const Double_t kCoolManifZPos     = fgkcm * 33.97;// 34.0 - 0.03 toll.
+    // Manifold supports
+    const Double_t kManifSuppWidth    = fgkmm * 24.0; // TO BE CHECKED!
+    const Double_t kManifSuppLen1     = fgkmm * 17.9;
+    const Double_t kManifSuppLen2     = fgkmm * 54.2;
+    const Double_t kManifSuppLen3     = fgkmm *  7.9;
+    const Double_t kManifSuppThick    = fgkmm *  1.5;
+    const Double_t kSuppScrewXPos     = fgkmm *  4.0;
+    const Double_t kSuppScrewZPos     = fgkmm *  3.0;
+    const Double_t kRThermalShield    = fgkcm *  9.9255; // MUST match with GeometrySupport
+    // Sector supports
+    const Double_t kSectSuppWidth     = fgkmm * 15.0;
+    const Double_t kSectSuppLen1      = fgkmm * 16.9; // TO BE CHECKED!
+    const Double_t kSectSuppLen2      = fgkmm * 35.1; // TO BE CHECKED!
+    const Double_t kSectSuppThick     = fgkmm *  1.5;
+    const Double_t kSectSuppDepth     = fgkmm * 17.78; // MUST match with GeometrySupport
+    const Double_t kSectScrewZPos     = fgkmm *  5.1; // TO BE CHECKED!
+
+    const Double_t kSectSuppZPos      = fgkcm * 26.5;
+    // Sector clips
+    const Double_t kSectClipLength    = fgkmm * 30.0;
+    const Double_t kSectClipWidth     = fgkmm * 28.53;
+    const Double_t kSectClipThick1    = fgkmm *  2.0;
+    const Double_t kSectClipThick2    = fgkmm *  0.715;
+    const Double_t kSectClipInStave   = fgkmm * 11.0; // Tuned
+    const Double_t kSectClipAngle     =         29.0; // Degree. Tuned
+    // M3 screws
+    const Double_t kScrewM3Diam       = fgkmm *  3.0;
+    const Double_t kScrewM3HeadThick  = fgkmm *  2.0;
+    const Double_t kScrewM3HeadRmin   = fgkmm *  1.5;
+    const Double_t kScrewM3HeadRmax   = fgkmm *  2.5;
+    const Double_t kScrewM3OutManifH  = fgkmm *  1.5;
+    // Central set pin (in sector support)
+    const Double_t kSetPinDiam        = fgkmm *  6.0;
+    const Double_t kSetPinHeadDiam    = fgkmm *  8.0;
+    const Double_t kSetPinHeadRmin    = fgkmm *  1.5;
+    const Double_t kSetPinHeadThick   = fgkmm *  1.5;
+    const Double_t kSetPinOutClipH    = fgkmm *  1.0;
+
+    // Local variables
+    Double_t xprof[12], yprof[12];
+    Double_t radius, theta;
+    Double_t xpos, ypos, zpos;
+    Double_t tmp;
+
+
+    // The cooling manifold: an Assembly
+    TGeoVolumeAssembly *coolmanifA = new TGeoVolumeAssembly("ITSSPDCoolManifSideA");
+    TGeoVolumeAssembly *coolmanifC = new TGeoVolumeAssembly("ITSSPDCoolManifSideC");
+
+    // The various parts of the manifold
+    TGeoBBox *manifblksh = new TGeoBBox(kCoolManifWidth/2,
+                                       kCoolManifThick/2,
+                                       kCoolManifLength/2);
+
+    TGeoBBox *manifinscubesh = new TGeoBBox(kCoolManifFitR2out,
+                                           kCoolManifFitR2out,
+                                           kCoolManifFitR2out);
+
+    TGeoTube *manifinscyl1sh = new TGeoTube(0, // TO BE CHECKED!
+                                           kCoolManifFitR1out,
+                                           kCoolManifFitH1/2);
+
+    TGeoTube *manifinscyl2sh = new TGeoTube(kCoolManifFitR2in,
+                                           kCoolManifFitR2out,
+                                           kCoolManifFitH2/2);
+
+    TGeoTube *manifcollcyl1sh = new TGeoTube(0,
+                                            kCoolManifCollR1,
+                                            kCoolManifCollH1/2);
+
+    TGeoTube *manifcollcyl2sh = new TGeoTube(0,
+                                            kCoolManifCollR2,
+                                            kCoolManifCollH2/2);
+
+    // The cooling manifold supports
+    const Double_t kCoolManifRPos = kCoolManifRPosCAD  +
+                             (manifinscubesh->GetDY() +
+                            2*manifinscyl1sh->GetDz() +
+                              manifblksh->GetDY()     );
+
+    const Double_t kManifSuppDepth = kRThermalShield -
+                                   (kCoolManifRPos + manifblksh->GetDY());
+
+    TGeoXtru *suppmanifsh = new TGeoXtru(2);
+
+    xprof[ 0] = kManifSuppLen2/2 + kManifSuppThick;
+    yprof[ 0] = 0;
+    xprof[ 1] = xprof[0];
+    yprof[ 1] = kManifSuppDepth;
+    xprof[ 2] = kManifSuppLen2/2 + kManifSuppLen3;
+    yprof[ 2] = yprof[1];
+    xprof[ 3] = xprof[2];
+    yprof[ 3] = yprof[2] + kManifSuppThick;
+    xprof[ 4] = kManifSuppLen2/2;
+    yprof[ 4] = yprof[3];
+    xprof[ 5] = xprof[4];
+    yprof[ 5] = kManifSuppThick;
+    xprof[ 6] = -xprof[5];
+    yprof[ 6] =  yprof[5];
+    xprof[ 7] = -xprof[4];
+    yprof[ 7] =  yprof[4];
+    xprof[ 8] = -(kManifSuppLen2/2 + kManifSuppLen1);
+    yprof[ 8] =  yprof[3];
+    xprof[ 9] =  xprof[8];
+    yprof[ 9] =  yprof[2];
+    xprof[10] = -xprof[1];
+    yprof[10] =  yprof[1];
+    xprof[11] = -xprof[0];
+    yprof[11] =  yprof[0];
+
+    suppmanifsh->DefinePolygon(12,xprof,yprof);
+    suppmanifsh->DefineSection(0,-kManifSuppWidth/2);
+    suppmanifsh->DefineSection(1, kManifSuppWidth/2);
+
+    // The screw head and body
+    TGeoTube *suppscrewbodysh = new TGeoTube(0, kScrewM3Diam/2,
+                                            kManifSuppThick/2);
+
+    TGeoPcon *suppscrewheadsh = new TGeoPcon(0, 360, 4);
+    suppscrewheadsh->DefineSection(0,-kScrewM3HeadThick/2,0, kScrewM3HeadRmax);
+    suppscrewheadsh->DefineSection(1, 0,                  0, kScrewM3HeadRmax);
+    suppscrewheadsh->DefineSection(2, 0,   kScrewM3HeadRmin, kScrewM3HeadRmax);
+    suppscrewheadsh->DefineSection(3, kScrewM3HeadThick/2,
+                                        kScrewM3HeadRmin, kScrewM3HeadRmax);
+
+    TGeoTube *clipscrewbodysh = new TGeoTube(0, kScrewM3Diam/2,
+                                            kSectClipThick1/2);
+
+    // The screw segment below the manifold and the sector clip
+    TGeoTube *screwoutmanifsh = new TGeoTube(0, kScrewM3Diam/2,
+                                            kScrewM3OutManifH/2);
+
+    // The sector supports
+    TGeoXtru *suppsectsh = new TGeoXtru(2);
+
+    xprof[ 0] = kSectSuppLen2/2 + kSectSuppThick;
+    yprof[ 0] = 0;
+    xprof[ 1] = xprof[0];
+    yprof[ 1] = kSectSuppDepth;
+    xprof[ 2] = kSectSuppLen2/2 + kSectSuppLen1;
+    yprof[ 2] = yprof[1];
+    xprof[ 3] = xprof[2];
+    yprof[ 3] = yprof[2] + kSectSuppThick;
+    xprof[ 4] = kSectSuppLen2/2;
+    yprof[ 4] = yprof[3];
+    xprof[ 5] = xprof[4];
+    yprof[ 5] = kSectSuppThick;
+    xprof[ 6] = -xprof[5];
+    yprof[ 6] =  yprof[5];
+    xprof[ 7] = -xprof[4];
+    yprof[ 7] =  yprof[4];
+    xprof[ 8] = -xprof[3];
+    yprof[ 8] =  yprof[3];
+    xprof[ 9] = -xprof[2];
+    yprof[ 9] =  yprof[2];
+    xprof[10] = -xprof[1];
+    yprof[10] =  yprof[1];
+    xprof[11] = -xprof[0];
+    yprof[11] =  yprof[0];
+
+    suppsectsh->DefinePolygon(12,xprof,yprof);
+    suppsectsh->DefineSection(0,-kSectSuppWidth/2);
+    suppsectsh->DefineSection(1, kSectSuppWidth/2);
+
+    // The sector clips
+    TGeoXtru *sectclipsh = new TGeoXtru(2);
+
+    xprof[ 0] =  kSectClipWidth/2;
+    yprof[ 0] =  0;
+    xprof[ 1] = -kSectClipWidth/2;
+    yprof[ 1] =  yprof[0];
+    xprof[ 2] =  xprof[1];
+    yprof[ 2] = -kSectClipThick1;
+    xprof[ 3] =  kSectClipWidth/2 - kSectClipThick2;
+    yprof[ 3] =  yprof[2];
+    xprof[ 4] =  xprof[3] + kSectClipInStave*SinD(kSectClipAngle);
+    yprof[ 4] = -kSectClipInStave*CosD(kSectClipAngle);
+    xprof[ 5] =  xprof[4] + kSectClipThick2*CosD(kSectClipAngle);
+    yprof[ 5] =  yprof[4] + kSectClipThick2*SinD(kSectClipAngle);
+
+    sectclipsh->DefinePolygon(6,xprof,yprof);
+    sectclipsh->DefineSection(0,-kSectClipLength/2);
+    sectclipsh->DefineSection(1, kSectClipLength/2);
+
+    // The central set pin head and body
+    TGeoTube *setpinbodysh = new TGeoTube(0, kSetPinDiam/2,
+                                         kSectSuppThick/2);
+
+    TGeoTube *setpinheadsh = new TGeoTube(kSetPinHeadRmin, kSetPinHeadDiam/2,
+                                         kSetPinHeadThick/2);
+
+    TGeoTube *pinclipbodysh = new TGeoTube(0, kSetPinDiam/2,
+                                          kSectClipThick1/2);
+
+    // The set pin segment below the sector clip
+    TGeoTube *setpinoutclipsh = new TGeoTube(0, kSetPinDiam/2,
+                                            kSetPinOutClipH/2);
+
+
+    // We have the shapes: now create the real volumes
+    TGeoMedium *medInox  = GetMedium("INOX$");
+    TGeoMedium *medCu    = GetMedium("COPPER$");
+    TGeoMedium *medSPDcf = GetMedium("SPD shield$");
+
+    TGeoVolume *manifblk = new TGeoVolume("ITSSPDBlkManif",
+                                         manifblksh,medInox);
+    manifblk->SetLineColor(kGreen+2);
+
+    TGeoVolume *manifinscube = new TGeoVolume("ITSSPDInsCubeManif",
+                                             manifinscubesh,medCu);
+    manifinscube->SetLineColor(kYellow);
+
+    TGeoVolume *manifinscyl1 = new TGeoVolume("ITSSPDInsCyl1Manif",
+                                             manifinscyl1sh,medCu);
+    manifinscyl1->SetLineColor(kYellow);
+
+    TGeoVolume *manifinscyl2 = new TGeoVolume("ITSSPDInsCyl2Manif",
+                                             manifinscyl2sh,medCu);
+    manifinscyl2->SetLineColor(kYellow);
+
+    TGeoVolume *manifcollcyl1 = new TGeoVolume("ITSSPDCollCyl1Manif",
+                                              manifcollcyl1sh,medCu);
+    manifcollcyl1->SetLineColor(kYellow);
+
+    TGeoVolume *manifcollcyl2 = new TGeoVolume("ITSSPDCollCyl2Manif",
+                                              manifcollcyl2sh,medCu);
+    manifcollcyl2->SetLineColor(kYellow);
+
+    TGeoVolume *suppmanif = new TGeoVolume("ITSSPDCoolManifSupp",
+                                              suppmanifsh,medSPDcf);
+    suppmanif->SetLineColor(7);
+
+    TGeoVolume *suppscrewbody = new TGeoVolume("ITSSPDSuppScrewBody",
+                                              suppscrewbodysh,medInox);
+    suppscrewbody->SetLineColor(kGray);
+
+    xpos = kCoolManifLength/2 - kSuppScrewZPos;
+    ypos = suppscrewbodysh->GetDz();
+    zpos = kCoolManifWidth/2  - kSuppScrewXPos;
+    suppmanif->AddNode(suppscrewbody, 1, new TGeoCombiTrans( xpos, ypos, zpos,
+                                        new TGeoRotation("",0,90,0)));
+    suppmanif->AddNode(suppscrewbody, 2, new TGeoCombiTrans( xpos, ypos,-zpos,
+                                        new TGeoRotation("",0,90,0)));
+    suppmanif->AddNode(suppscrewbody, 3, new TGeoCombiTrans(-xpos, ypos, zpos,
+                                        new TGeoRotation("",0,90,0)));
+    suppmanif->AddNode(suppscrewbody, 4, new TGeoCombiTrans(-xpos, ypos,-zpos,
+                                        new TGeoRotation("",0,90,0)));
+
+    TGeoVolume *suppscrewhead = new TGeoVolume("ITSSPDSuppScrewHead",
+                                              suppscrewheadsh,medInox);
+    suppscrewhead->SetLineColor(kGray);
+
+    TGeoVolume *screwoutmanif = new TGeoVolume("ITSSPDSuppScrewOutManif",
+                                              screwoutmanifsh,medInox);
+    screwoutmanif->SetLineColor(kGray);
+
+    TGeoVolume *suppsect = new TGeoVolume("ITSSPDCoolSectorSupp",
+                                         suppsectsh,medSPDcf);
+    suppsect->SetLineColor(7);
+
+    xpos = kSectSuppLen2/2 - kSectScrewZPos;
+    ypos = suppscrewbodysh->GetDz();
+    suppsect->AddNode(suppscrewbody, 1, new TGeoCombiTrans( xpos, ypos, 0,
+                                       new TGeoRotation("",0,90,0)));
+    suppsect->AddNode(suppscrewbody, 2, new TGeoCombiTrans(-xpos, ypos, 0,
+                                       new TGeoRotation("",0,90,0)));
+
+    TGeoVolume *setpinbody = new TGeoVolume("ITSSPDSetPinBody",
+                                           setpinbodysh,medInox);
+    setpinbody->SetLineColor(kGray);
+
+    ypos = setpinbodysh->GetDz();
+    suppsect->AddNode(setpinbody, 1, new TGeoCombiTrans( 0, ypos, 0,
+                                       new TGeoRotation("",0,90,0)));
+
+    TGeoVolume *setpinhead = new TGeoVolume("ITSSPDSetPinHead",
+                                           setpinheadsh,medInox);
+    setpinhead->SetLineColor(kGray);
+
+    TGeoVolume *sectclip = new TGeoVolume("ITSSPDCoolSectorClip",
+                                         sectclipsh,medSPDcf);
+    sectclip->SetLineColor(7);
+
+    TGeoVolume *clipscrewbody = new TGeoVolume("ITSSPDClipScrewBody",
+                                              clipscrewbodysh,medInox);
+    clipscrewbody->SetLineColor(kGray);
+
+    ypos = -clipscrewbodysh->GetDz();
+    zpos = kSectSuppLen2/2 - kSectScrewZPos;
+    sectclip->AddNode(clipscrewbody, 1, new TGeoCombiTrans( 0, ypos, zpos,
+                                       new TGeoRotation("",0,90,0)));
+    sectclip->AddNode(clipscrewbody, 2, new TGeoCombiTrans( 0, ypos,-zpos,
+                                       new TGeoRotation("",0,90,0)));
+
+    TGeoVolume *pinclipbody = new TGeoVolume("ITSSPDClipPinBody",
+                                            pinclipbodysh,medInox);
+    pinclipbody->SetLineColor(kGray);
+
+    ypos = -pinclipbodysh->GetDz();
+    sectclip->AddNode(pinclipbody, 1, new TGeoCombiTrans( 0, ypos, 0,
+                                       new TGeoRotation("",0,90,0)));
+
+    TGeoVolume *setpinoutclip = new TGeoVolume("ITSSPDSetPinOutClip",
+                                              setpinoutclipsh,medInox);
+    setpinoutclip->SetLineColor(kGray);
+
+
+    // Add all volumes in the assemblies
+    coolmanifA->AddNode(manifblk,1,0);
+    coolmanifC->AddNode(manifblk,1,0);
+
+    ypos = manifblksh->GetDY() + manifinscyl1sh->GetDz();
+    zpos = manifblksh->GetDZ() - manifinscyl1sh->GetRmax() - kCoolManifFitZPos;
+    coolmanifA->AddNode(manifinscyl1, 1, new TGeoCombiTrans(0, -ypos, zpos,
+                                        new TGeoRotation("",0,90,0)));
+    coolmanifC->AddNode(manifinscyl1, 1, new TGeoCombiTrans(0, -ypos, zpos,
+                                        new TGeoRotation("",0,90,0)));
+
+    ypos += (manifinscyl1sh->GetDz() + manifinscubesh->GetDY());
+    coolmanifA->AddNode(manifinscube, 1, new TGeoTranslation(0, -ypos, zpos));
+    coolmanifC->AddNode(manifinscube, 1, new TGeoTranslation(0, -ypos, zpos));
+
+    zpos += (manifinscubesh->GetDZ() + manifinscyl2sh->GetDz());
+    coolmanifA->AddNode(manifinscyl2, 1, new TGeoTranslation(0, -ypos, zpos));
+    coolmanifC->AddNode(manifinscyl2, 1, new TGeoTranslation(0, -ypos, zpos));
+
+    ypos = manifblksh->GetDY();
+    coolmanifA->AddNode(suppmanif, 1, new TGeoCombiTrans(0, ypos, 0,
+                                        new TGeoRotation("",-90,90,90)));
+    coolmanifC->AddNode(suppmanif, 1, new TGeoCombiTrans(0, ypos, 0,
+                                        new TGeoRotation("",-90,90,90)));
+
+    ypos += (kManifSuppThick + kScrewM3HeadThick/2);
+    xpos = kCoolManifWidth/2   - kSuppScrewXPos;
+    zpos = kCoolManifLength/2  - kSuppScrewZPos;
+    coolmanifA->AddNode(suppscrewhead, 1, new TGeoCombiTrans( xpos, ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 1, new TGeoCombiTrans( xpos, ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(suppscrewhead, 2, new TGeoCombiTrans( xpos, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 2, new TGeoCombiTrans( xpos, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(suppscrewhead, 3, new TGeoCombiTrans(-xpos, ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 3, new TGeoCombiTrans(-xpos, ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(suppscrewhead, 4, new TGeoCombiTrans(-xpos, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 4, new TGeoCombiTrans(-xpos, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    ypos = manifblksh->GetDY() + screwoutmanifsh->GetDz();
+    coolmanifA->AddNode(screwoutmanif, 1, new TGeoCombiTrans( xpos,-ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 1, new TGeoCombiTrans( xpos,-ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(screwoutmanif, 2, new TGeoCombiTrans( xpos,-ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 2, new TGeoCombiTrans( xpos,-ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(screwoutmanif, 3, new TGeoCombiTrans(-xpos,-ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 3, new TGeoCombiTrans(-xpos,-ypos, zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifA->AddNode(screwoutmanif, 4, new TGeoCombiTrans(-xpos,-ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 4, new TGeoCombiTrans(-xpos,-ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    ypos = manifblksh->GetDY() + suppmanifsh->GetY(1) - suppsectsh->GetY(1);
+    zpos = manifblksh->GetDZ() + (kCoolManifZPos - kSectSuppZPos);
+    coolmanifA->AddNode(suppsect, 1, new TGeoCombiTrans(0, ypos,-zpos,
+                                        new TGeoRotation("",-90,90,90)));
+    coolmanifC->AddNode(suppsect, 1, new TGeoCombiTrans(0, ypos,-zpos,
+                                        new TGeoRotation("",-90,90,90)));
+
+    tmp = ypos; // Save it to avoid recomputing
+
+    ypos += (kSectSuppThick + kScrewM3HeadThick/2);
+    zpos += (kSectSuppLen2/2 - kSectScrewZPos);
+    coolmanifA->AddNode(suppscrewhead, 5, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 5, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    zpos -= 2*(kSectSuppLen2/2 - kSectScrewZPos);
+    coolmanifA->AddNode(suppscrewhead, 6, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(suppscrewhead, 6, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    ypos = tmp + kSectSuppThick + kSetPinHeadThick/2;
+    zpos += (kSectSuppLen2/2 - kSectScrewZPos);
+    coolmanifA->AddNode(setpinhead, 1, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(setpinhead, 1, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    ypos = tmp - 8.e-5; // Avoid microscopic overlap
+    tmp = ypos;
+    coolmanifA->AddNode(sectclip, 1, new TGeoTranslation( 0, ypos,-zpos));
+    coolmanifC->AddNode(sectclip, 1, new TGeoCombiTrans ( 0, ypos,-zpos,
+                                         new TGeoRotation("",-90,180,90)));
+
+    ypos -= (kSectClipThick1 + setpinoutclipsh->GetDz());
+    coolmanifA->AddNode(setpinoutclip, 1, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(setpinoutclip, 1, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    ypos = tmp - (kSectClipThick1 + screwoutmanifsh->GetDz());
+    zpos += (kSectSuppLen2/2 - kSectScrewZPos);
+    coolmanifA->AddNode(screwoutmanif, 5, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 5, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    zpos -= 2*(kSectSuppLen2/2 - kSectScrewZPos);
+    coolmanifA->AddNode(screwoutmanif, 6, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+    coolmanifC->AddNode(screwoutmanif, 6, new TGeoCombiTrans( 0, ypos,-zpos,
+                                         new TGeoRotation("",0,-90,0)));
+
+    xpos = manifblksh->GetDX() - kCoolManifCollXPos;
+    ypos = manifblksh->GetDY() + manifcollcyl1sh->GetDz();
+    zpos =-manifblksh->GetDZ() + kCoolManifCollZ0;
+    for (Int_t i=0; i<3; i++) {
+      coolmanifA->AddNode(manifcollcyl1, 2*i+1,
+                         new TGeoCombiTrans( xpos, -ypos, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifA->AddNode(manifcollcyl1, 2*i+2,
+                         new TGeoCombiTrans(-xpos, -ypos, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifC->AddNode(manifcollcyl1, 2*i+1,
+                         new TGeoCombiTrans( xpos, -ypos, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifC->AddNode(manifcollcyl1, 2*i+2,
+                         new TGeoCombiTrans(-xpos, -ypos, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      Double_t y = ypos + manifcollcyl1sh->GetDz() + manifcollcyl2sh->GetDz();
+      coolmanifA->AddNode(manifcollcyl2, 2*i+1,
+                         new TGeoCombiTrans( xpos, -y, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifA->AddNode(manifcollcyl2, 2*i+2,
+                         new TGeoCombiTrans(-xpos, -y, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifC->AddNode(manifcollcyl2, 2*i+1,
+                         new TGeoCombiTrans( xpos, -y, zpos,
+                                            new TGeoRotation("",0,90,0)));
+      coolmanifC->AddNode(manifcollcyl2, 2*i+2,
+                         new TGeoCombiTrans(-xpos, -y, zpos,
+                                            new TGeoRotation("",0,90,0)));
+
+      zpos += kCoolManifCollDZ;
+    }
+
+    // Now add the cooling tubes to the assembly
+    CreateCoolingTubes(coolmanifA, kFALSE);
+    CreateCoolingTubes(coolmanifC, kTRUE);
+
+
+    // Finally put everything in the mother volume
+    radius = kCoolManifRPos + 1.e-5; // Avoid microscopic overlap
+    zpos = kCoolManifZPos + manifblksh->GetDZ();
+    for (Int_t i=0; i<10; i++) {
+      theta = 36.*i;
+      moth->AddNode(coolmanifA, i+1, new TGeoCombiTrans(radius*SinD(theta),
+                                                       radius*CosD(theta),
+                                                       zpos,
+                                         new TGeoRotation("",-theta,0,0)));
+      moth->AddNode(coolmanifC, i+1, new TGeoCombiTrans(radius*SinD(theta),
+                                                       radius*CosD(theta),
+                                                      -zpos,
+                                         new TGeoRotation("",90-theta,180,-90)));
+    }
+
+
+}
+
+
+//______________________________________________________________________
+void AliITSv11GeometrySPD::CreateCoolingTubes(TGeoVolume *moth, Bool_t sideC) const
+{
+    //
+    // Private method to implement SPD cooling tubes
+    // going from the manifolds to the staves
+    // Since their form is quite complicate (especially on Side C
+    // where capillaries are located) a separate method is used
+    // If sideC is true, the cooling tubes on Side C are created
+    // along with the cooling loops (aka "capillaries"), otherwise
+    // the (simpler) tubes on Side A get created.
+    //
+    // In all variables:  L = Left (X > 0)   R = Right (X < 0)
+    //
+    // Created:      10 Nov 2012  Mario Sitta
+    //
+    // Data provided by C.Gargiulo from CAD
+
+    // Cooling manifolds - THESE VALUES *MUST* MATCH WITH CALLING METHOD!
+    const Double_t kCoolManifWidth    = fgkmm * 22.0;
+    const Double_t kCoolManifLength   = fgkmm * 50.0;
+    const Double_t kCoolManifThick    = fgkmm *  7.0;
+    const Double_t kCoolManifCollH1   = fgkmm *  2.5;
+    const Double_t kCoolManifCollH2   = fgkmm *  5.0;
+    // Cooling pipes
+    const Double_t kCoolPipeSideARin  = fgkmm *  1.5;
+    const Double_t kCoolPipeSideARout = fgkmm *  1.8;
+    const Double_t kCoolPipeSideCRin  = fgkmm *  0.5;
+    const Double_t kCoolPipeSideCRout = fgkmm *  0.85;
+    const Double_t kCoolPipeHeight    = fgkmm *  1.923;
+    const Double_t kCoolPipeCRadiusL[3] = {11.0, 14.0, 31.34};// TO BE CHECKED!
+    const Double_t kCoolPipeCRadiusR[3] = {12.0, 14.0, 35.54};// TO BE CHECKED!
+    const Double_t kCoolPipeARadiusL12[2] = {14.0, 30.0};
+    const Double_t kCoolPipeARadiusR12[2] = {14.0, 30.0};
+    const Double_t kCoolPipeARadiusL34[2] = {22.0, 30.0};
+    const Double_t kCoolPipeARadiusR34[2] = {22.0, 30.0};
+    const Double_t kCoolPipeARadiusL[3]= {14.0, 14.0, 31.34}; // TO BE CHECKED!
+    const Double_t kCoolPipeARadiusR[3]= {14.0, 14.0, 35.54}; // TO BE CHECKED!
+    const Double_t kCoolPipeZSPD      = fgkcm *  8.47;
+    // Cooling pipes position - THESE VALUES *MUST* MATCH WITH CALLING METHOD!
+    const Double_t kCoolManifCollXPos = fgkmm *  5.0;
+    const Double_t kCoolManifCollDZ   = fgkmm * 13.0;
+    const Double_t kCoolManifCollZ0   = fgkmm *  9.0;
+
+    Int_t kPurple = 6; // Purple (Root does not define it)
+
+    // Local variables
+    Double_t xpos, ypos, zpos;
+    Char_t pipename[11];
+
+    //
+    TGeoMedium *medPhynox  = GetMedium("PHYNOX$");
+    TGeoMedium *medFreon   = GetMedium("Freon$");
+    TGeoMedium *medGasFr   = GetMedium("GASEOUS FREON$");
+
+    // The cooling tubes are created as CableRound volumes
+    // because it's easier to compose them piece by piece
+    AliITSv11GeomCableRound *coolpipe[6];
+
+    if (sideC)
+      for (Int_t i = 0; i<6; i++) {
+       snprintf(pipename,11,"coolPipeC%d",i+1);
+       coolpipe[i] = new AliITSv11GeomCableRound(pipename,kCoolPipeSideCRout);
+       coolpipe[i]->SetNLayers(2);
+       coolpipe[i]->SetLayer(0, kCoolPipeSideCRin, medFreon, kPurple);
+       coolpipe[i]->SetLayer(1,(kCoolPipeSideCRout-kCoolPipeSideCRin),
+                             medPhynox, kYellow);
+      }
+    else
+      for (Int_t i = 0; i<6; i++) {
+       snprintf(pipename,11,"coolPipeA%d",i+1);
+       coolpipe[i] = new AliITSv11GeomCableRound(pipename,kCoolPipeSideARout);
+       coolpipe[i]->SetNLayers(2);
+       coolpipe[i]->SetLayer(0, kCoolPipeSideARin, medGasFr, kPurple);
+       coolpipe[i]->SetLayer(1,(kCoolPipeSideARout-kCoolPipeSideARin),
+                             medPhynox, kYellow);
+      }
+
+     // Now place them in the mother assembly
+     xpos = kCoolManifWidth/2  - kCoolManifCollXPos;
+     ypos = kCoolManifThick/2  + kCoolManifCollH1 + kCoolManifCollH2;
+     zpos =-kCoolManifLength/2 + kCoolManifCollZ0;
+
+     if (sideC) { // On Side C tubes are simpler and can be created in a loop
+
+       for (Int_t i=0; i<3; i++) {
+
+        Double_t coordL[3] = { xpos,-ypos,zpos};
+        Double_t coordR[3] = {-xpos,-ypos,zpos};
+        Double_t vect[3] = {0, 1, 0};
+        coolpipe[2*i]->AddCheckPoint(moth, 0, coordL, vect);
+        coolpipe[2*i+1]->AddCheckPoint(moth, 0, coordR, vect);
+        coordL[1] -= kCoolPipeHeight;
+        coordR[1] = coordL[1];
+        coolpipe[2*i]->AddCheckPoint(moth, 1, coordL, vect);
+        coolpipe[2*i+1]->AddCheckPoint(moth, 1, coordR, vect);
+        coordL[1] -= kCoolPipeCRadiusL[i]*fgkmm;
+        coordL[2] -= kCoolPipeCRadiusL[i]*fgkmm;
+        coordR[1] -= kCoolPipeCRadiusR[i]*fgkmm;
+        coordR[2] -= kCoolPipeCRadiusR[i]*fgkmm;
+        vect[1] = 0;
+        vect[2] = -1;
+        coolpipe[2*i]->AddCheckPoint(moth, 2, coordL, vect);
+        coolpipe[2*i+1]->AddCheckPoint(moth, 2, coordR, vect);
+        coordL[2] = -kCoolPipeZSPD;
+        coordR[2] = -kCoolPipeZSPD;
+        coolpipe[2*i]->AddCheckPoint(moth, 3, coordL, vect);
+        coolpipe[2*i+1]->AddCheckPoint(moth, 3, coordR, vect);
+
+        zpos += kCoolManifCollDZ;
+       }
+
+       for (Int_t i=0; i<6; i++) {
+        coolpipe[i]->SetInitialNode(moth);
+        
+        coolpipe[i]->CreateAndInsertTubeSegment(1);
+        coolpipe[i]->CreateAndInsertTorusSegment(2,180);
+        coolpipe[i]->CreateAndInsertTubeSegment(3);
+       }
+
+     } else { // On Side A tubes are all different so are created one by one
+
+       Double_t coordL[3] = { xpos,-ypos,zpos};
+       Double_t coordR[3] = {-xpos,-ypos,zpos};
+       Double_t vect[3] = {0, 1, 0};
+       coolpipe[0]->AddCheckPoint(moth, 0, coordL, vect);
+       coolpipe[1]->AddCheckPoint(moth, 0, coordR, vect);
+       coordL[1] -= kCoolPipeHeight;
+       coordR[1] = coordL[1];
+       coolpipe[0]->AddCheckPoint(moth, 1, coordL, vect);
+       coolpipe[1]->AddCheckPoint(moth, 1, coordR, vect);
+       coordL[1] -=    SinD(45) *kCoolPipeARadiusL12[0]*fgkmm;
+       coordL[2] -= (1+CosD(45))*kCoolPipeARadiusL12[0]*fgkmm;
+       coordR[1] -=    SinD(45) *kCoolPipeARadiusR12[0]*fgkmm;
+       coordR[2] -= (1+CosD(45))*kCoolPipeARadiusR12[0]*fgkmm;
+       vect[1] = TMath::Sqrt(2);
+       vect[2] = -vect[1];
+       coolpipe[0]->AddCheckPoint(moth, 2, coordL, vect);
+       coolpipe[1]->AddCheckPoint(moth, 2, coordR, vect);
+       coordL[1] += (1-CosD(45))*kCoolPipeARadiusL12[1]*fgkmm;
+       coordL[2] -=    SinD(45) *kCoolPipeARadiusL12[1]*fgkmm;
+       coordR[1] += (1-CosD(45))*kCoolPipeARadiusR12[1]*fgkmm;
+       coordR[2] -=    SinD(45) *kCoolPipeARadiusR12[1]*fgkmm;
+       vect[1] = 0;
+       vect[2] = -1;
+       coolpipe[0]->AddCheckPoint(moth, 3, coordL, vect);
+       coolpipe[1]->AddCheckPoint(moth, 3, coordR, vect);
+       coordL[2] = -kCoolPipeZSPD;
+       coordR[2] = -kCoolPipeZSPD;
+       coolpipe[0]->AddCheckPoint(moth, 4, coordL, vect);
+       coolpipe[1]->AddCheckPoint(moth, 4, coordR, vect);
+
+       coolpipe[0]->SetInitialNode(moth); 
+       coolpipe[0]->CreateAndInsertTubeSegment(1);
+       coolpipe[0]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[0]->CreateAndInsertTorusSegment(3,180);
+       coolpipe[0]->CreateAndInsertTubeSegment(4);
+
+       coolpipe[1]->SetInitialNode(moth); 
+       coolpipe[1]->CreateAndInsertTubeSegment(1);
+       coolpipe[1]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[1]->CreateAndInsertTorusSegment(3,180);
+       coolpipe[1]->CreateAndInsertTubeSegment(4);
+
+       zpos += kCoolManifCollDZ;
+
+       coordL[0] = xpos; coordL[1] = -ypos; coordL[2] = zpos;
+       coordR[0] =-xpos; coordR[1] = -ypos; coordR[2] = zpos;
+       vect[0] = 0; vect[1] = 1; vect[2] = 0;
+
+       coolpipe[2]->AddCheckPoint(moth, 0, coordL, vect);
+       coolpipe[3]->AddCheckPoint(moth, 0, coordR, vect);
+       coordL[1] -= kCoolPipeHeight;
+       coordR[1] = coordL[1];
+       coolpipe[2]->AddCheckPoint(moth, 1, coordL, vect);
+       coolpipe[3]->AddCheckPoint(moth, 1, coordR, vect);
+       coordL[1] -=    SinD(45) *kCoolPipeARadiusL34[0]*fgkmm;
+       coordL[2] -= (1+CosD(45))*kCoolPipeARadiusL34[0]*fgkmm;
+       coordR[1] -=    SinD(45) *kCoolPipeARadiusR34[0]*fgkmm;
+       coordR[2] -= (1+CosD(45))*kCoolPipeARadiusR34[0]*fgkmm;
+       vect[1] = TMath::Sqrt(2);
+       vect[2] = -vect[1];
+       coolpipe[2]->AddCheckPoint(moth, 2, coordL, vect);
+       coolpipe[3]->AddCheckPoint(moth, 2, coordR, vect);
+       coordL[1] += (1-CosD(45))*kCoolPipeARadiusL34[1]*fgkmm;
+       coordL[2] -=    SinD(45) *kCoolPipeARadiusL34[1]*fgkmm;
+       coordR[1] += (1-CosD(45))*kCoolPipeARadiusR34[1]*fgkmm;
+       coordR[2] -=    SinD(45) *kCoolPipeARadiusR34[1]*fgkmm;
+       vect[1] = 0;
+       vect[2] = -1;
+       coolpipe[2]->AddCheckPoint(moth, 3, coordL, vect);
+       coolpipe[3]->AddCheckPoint(moth, 3, coordR, vect);
+       coordL[2] = -kCoolPipeZSPD;
+       coordR[2] = -kCoolPipeZSPD;
+       coolpipe[2]->AddCheckPoint(moth, 4, coordL, vect);
+       coolpipe[3]->AddCheckPoint(moth, 4, coordR, vect);
+
+       coolpipe[2]->SetInitialNode(moth); 
+       coolpipe[2]->CreateAndInsertTubeSegment(1);
+       coolpipe[2]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[2]->CreateAndInsertTorusSegment(3,180);
+       coolpipe[2]->CreateAndInsertTubeSegment(4);
+
+       coolpipe[3]->SetInitialNode(moth); 
+       coolpipe[3]->CreateAndInsertTubeSegment(1);
+       coolpipe[3]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[3]->CreateAndInsertTorusSegment(3,180);
+       coolpipe[3]->CreateAndInsertTubeSegment(4);
+
+       zpos += kCoolManifCollDZ;
+
+       coordL[0] = xpos; coordL[1] = -ypos; coordL[2] = zpos;
+       coordR[0] =-xpos; coordR[1] = -ypos; coordR[2] = zpos;
+       vect[0] = 0; vect[1] = 1; vect[2] = 0;
+
+       coolpipe[4]->AddCheckPoint(moth, 0, coordL, vect);
+       coolpipe[5]->AddCheckPoint(moth, 0, coordR, vect);
+       coordL[1] -= kCoolPipeHeight;
+       coordR[1] = coordL[1];
+       coolpipe[4]->AddCheckPoint(moth, 1, coordL, vect);
+       coolpipe[5]->AddCheckPoint(moth, 1, coordR, vect);
+       coordL[1] -= kCoolPipeARadiusL[2]*fgkmm;
+       coordL[2] -= kCoolPipeARadiusL[2]*fgkmm;
+       coordR[1] -= kCoolPipeARadiusR[2]*fgkmm;
+       coordR[2] -= kCoolPipeARadiusR[2]*fgkmm;
+       vect[1] = 0;
+       vect[2] = -1;
+       coolpipe[4]->AddCheckPoint(moth, 2, coordL, vect);
+       coolpipe[5]->AddCheckPoint(moth, 2, coordR, vect);
+       coordL[2] = -kCoolPipeZSPD;
+       coordR[2] = -kCoolPipeZSPD;
+       coolpipe[4]->AddCheckPoint(moth, 3, coordL, vect);
+       coolpipe[5]->AddCheckPoint(moth, 3, coordR, vect);
+
+       coolpipe[4]->SetInitialNode(moth);
+       coolpipe[4]->CreateAndInsertTubeSegment(1);
+       coolpipe[4]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[4]->CreateAndInsertTubeSegment(3);
+
+       coolpipe[5]->SetInitialNode(moth);
+       coolpipe[5]->CreateAndInsertTubeSegment(1);
+       coolpipe[5]->CreateAndInsertTorusSegment(2,180);
+       coolpipe[5]->CreateAndInsertTubeSegment(3);
+
+     } // if (sideC)
+
+     if(GetDebug(3))
+       for (Int_t i=0; i<6; i++)
+        coolpipe[i]->PrintCheckPoints();
+
+}
+
+
+//______________________________________________________________________
 TGeoVolume* AliITSv11GeometrySPD::CreateExtender(
     const Double_t *extenderParams, const TGeoMedium *extenderMedium,
     TArrayD& sizes) const
@@ -3287,7 +4196,7 @@ Int_t layer,Int_t idxCentral,Int_t idxSide,TArrayD &sizes,TGeoManager *mgr)
     CreateClip(clipSize, kTRUE, mgr);
     // define clip movements (width direction)
     sizes[3] = xBus + 0.5*busThickness;
-    sizes[4] = 0.5 * (fullWidth - busWidth) - clipSize[6] - fgkmm*0.48;
+    sizes[4] = 0.5 * (fullWidth - busWidth) - clipSize[6] - fgkmm*0.26;
     sizes[5] = zBus + busSize[4];
     sizes[6] = zBus + busSize[5];
 
@@ -3544,27 +4453,7 @@ void AliITSv11GeometrySPD::StavesInSector(TGeoVolume *moth, TGeoManager *mgr)
     
     
     // Add a box representing the collector for cooling tubes
-    Double_t collWidth     = fgkmm * 22.0;
-    Double_t collLength    = fgkmm * 50.0;
-    Double_t collThickness = fgkmm *  7.0;
-    Double_t collInSize    = fgkmm * 10.5;
-    
-    TGeoMedium *medColl   = GetMedium("INOX$");
-    TGeoMedium *medCollIn = GetMedium("COPPER$");
-    TGeoVolume *vColl     = mgr->MakeBox("ITSSPDSectorTubeColl"  , medColl, 0.5*collWidth, 0.5*collThickness, 0.5*collLength);
-    TGeoVolume *vCollIn   = mgr->MakeBox("ITSSPDSectorTubeCollIn", medCollIn, 0.5*collInSize, 0.5*collInSize, 0.5*collInSize);
-    vColl->SetLineColor(kGreen+2);
-    vCollIn->SetLineColor(kYellow);
-    
-    TGeoTranslation *tr1 = new TGeoTranslation( 0.1, 1.2,  35.0);
-    TGeoTranslation *tr2 = new TGeoTranslation(-0.1, 1.2, -35.0);
-    TGeoTranslation *tr3 = new TGeoTranslation( 0.1, 1.2 - 0.5*(collThickness+collInSize),  35.0 + 0.5*(collLength - collInSize));
-    TGeoTranslation *tr4 = new TGeoTranslation(-0.1, 1.2 - 0.5*(collThickness+collInSize), -35.0 - 0.5*(collLength - collInSize));
-    
-    moth->AddNode(vColl, 0, tr1);
-    moth->AddNode(vColl, 1, tr2);
-    moth->AddNode(vCollIn, 0, tr3);
-    moth->AddNode(vCollIn, 1, tr4);
+    // MOVED TO CreateServices() - M.S. 25 jul 12
     
 }
 //______________________________________________________________________
@@ -3690,15 +4579,19 @@ void AliITSv11GeometrySPD::ReadAscii(istream* is)
     //   none.
     //
     Int_t i,j,k,n;
-    Double_t gapLadder,GapHalfStave;
-
-    *is>>gapLadder>>GapHalfStave>>n;
+    Double_t gapLadder,gapHalfStave;
+    const Int_t kLimits = 100;
+    *is>>gapLadder>>gapHalfStave>>n;
     if(n!=6){
-        Warning("ReadAscii","fAddStave Array !=6 n=%d",n);
+      AliError(Form("fAddStave Array !=6 n=%d",n));
         return;
     } // end if
     for(i=0;i<n;i++) *is>>fAddStave[i];
     *is>>n;
+    if(n<0 || n> kLimits){
+      AliError("Anomalous value for parameter n");
+      return;
+    } 
     fSPDsectorX0.Set(n);
     fSPDsectorY0.Set(n);
     fSPDsectorX1.Set(n);