- AliITSv11GeometrySPD.h : changed signature of method CreateConeModule
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2010 17:24:47 +0000 (17:24 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2010 17:24:47 +0000 (17:24 +0000)
- AliITSv11GeometrySPD.cxx : mods in CreateConeModule to prolong cooling tubes where they were missing and to add freon
inside tubes; CreateCones has been modfied to add new volumes

- AliITSv11GeometrySupport.cxx : mods in SDDCone to add cables inside the holes of the SDD cone;
  mods in SPDCableTraysSideA and SPDCableTraysSideC to add HV cbles in the trays and freon in the cooling tubes

- AliITSv11Hybrid.cxx : mods in CreateMaterials to define gaseous Freon and the average material for SPD HV cables.

Mario Sitta

ITS/AliITSv11GeometrySPD.cxx
ITS/AliITSv11GeometrySPD.h
ITS/AliITSv11GeometrySupport.cxx
ITS/AliITSv11Hybrid.cxx

index 5262eb9..ef2b3e0 100644 (file)
@@ -2908,36 +2908,64 @@ TGeoVolumeAssembly* AliITSv11GeometrySPD::CreatePixelBus
 }
 
 //______________________________________________________________________
-TList* AliITSv11GeometrySPD::CreateConeModule(TGeoManager *mgr) const
+TList* AliITSv11GeometrySPD::CreateConeModule(const Double_t angrot,
+                                             TGeoManager *mgr) const
 {
+    //
+    // Creates all services modules and places them in a TList
+    // angrot is the rotation angle (passed as an argument to avoid
+    // defining the same quantity in two different places)
+    //
+    // Created:      ?? ??? 2008  Alberto Pulvirenti
+    // Updated:      03 May 2010  Mario Sitta
+    //
+
     TGeoMedium *medInox  = GetMedium("INOX$",mgr);
     TGeoMedium *medExt   = GetMedium("SDDKAPTON (POLYCH2)$", mgr);
     TGeoMedium *medPlate = GetMedium("SPD C (M55J)$", mgr);
+    TGeoMedium *medFreon = GetMedium("Freon$", mgr);
+    TGeoMedium *medGas   = GetMedium("GASEOUS FREON$", mgr);
 
     Double_t extThickness = fgkmm * 0.25;
     Double_t ext1Length   = fgkmm * (26.7 - 10.0);
-    Double_t ext2Length   = fgkmm * (285.0 - ext1Length + extThickness);
+//    Double_t ext2Length   = fgkmm * (285.0 - ext1Length + extThickness);
+    Double_t ext2Length   = fgkmm * 285.0 - ext1Length + extThickness;
 
-    Double_t cableThickness = 1.5 * fgkmm;
-    Double_t cableL1 = 350.0 * fgkmm - extThickness - ext1Length - ext2Length;
-    Double_t cableL2 = 340.0 * fgkmm;
+    const Double_t kCableThickness  =   1.5  *fgkmm;
+    Double_t cableL1 = 340.0 * fgkmm - extThickness - ext1Length - ext2Length;
+    Double_t cableL2 = 300.0 * fgkmm;
     //Double_t cableL3 = 570.0 * fgkmm;
     Double_t cableL3 = 57.0 * fgkmm;
     Double_t cableW1 =  11.0 * fgkmm;
     Double_t cableW2 =  30.0 * fgkmm;
     Double_t cableW3 =  50.0 * fgkmm;
 
-    Double_t mcmThickness = 1.2 *fgkmm;
-    Double_t mcmLength = cableL1 + cableL2 + cableL3;
-    Double_t mcmWidth = cableW1;
+    const Double_t kMCMLength       =   cableL1 + cableL2 + cableL3;
+    const Double_t kMCMWidth        =   cableW1;
+    const Double_t kMCMThickness    =   1.2  *fgkmm;
 
-    Double_t plateLength    = 200.0 * fgkmm;
-    Double_t plateWidth     =  50.0 * fgkmm;
-    Double_t plateThickness =   5.0 * fgkmm;
+    const Double_t kPlateLength     = 200.0  *fgkmm;
+    const Double_t kPlateWidth      =  50.0  *fgkmm;
+    const Double_t kPlateThickness  =   5.0  *fgkmm;
+
+    const Double_t kConeTubeRmin    =   5.0  *fgkmm;
+    const Double_t kConeTubeRmax    =   6.0  *fgkmm;
+
+    const Double_t kHorizTubeLen    = 150.0  *fgkmm; //!!!TO BE CHECKED!!!
+    const Double_t kYtoHalfStave    =   6.8  *fgkmm; //!!!TO BE CHECKED!!!
 
     Double_t x[12], y[12];
+    Double_t xloc, yloc, zloc;
+
+    Int_t kPurple = 6; // Purple (Root does not define it)
+
+    TGeoVolumeAssembly* container[3];
+    container[0] = new TGeoVolumeAssembly("ITSSPDConeModule");
+    container[1] = new TGeoVolumeAssembly("ITSSPDCoolingModuleSideA");
+    container[2] = new TGeoVolumeAssembly("ITSSPDCoolingModuleSideC");
 
-    x[0] = 7.5;
+    // The extender on the cone as a Xtru
+    x[0] = 0.0;
     y[0] = 0.0 + 0.5 * cableW1;
 
     x[1] = x[0] + cableL1 - 0.5*(cableW2 - cableW1);
@@ -2960,53 +2988,139 @@ TList* AliITSv11GeometrySPD::CreateConeModule(TGeoManager *mgr) const
         y[i] = -y[11 - i];
     }
 
-    TGeoVolumeAssembly* container[2];
-    container[0] = new TGeoVolumeAssembly("ITSSPDConeModule");
-    container[1] = new TGeoVolumeAssembly("ITSSPDCoolingModule");
-
     TGeoXtru *shCable = new TGeoXtru(2);
     shCable->DefinePolygon(12, x, y);
-    shCable->DefineSection(0, 0., 0., 0., 1.0);
-    shCable->DefineSection(1, cableThickness, 0., 0., 1.0);
+    shCable->DefineSection(0, 0.0);
+    shCable->DefineSection(1, kCableThickness);
 
     TGeoVolume *volCable = new TGeoVolume("ITSSPDExtender", shCable, medExt);
     volCable->SetLineColor(kGreen);
 
-    TGeoVolume *volTube = gGeoManager->MakeTube("ITSSPDCoolingTubeCone", medInox, 5.*fgkmm, 6.*fgkmm, 0.5*(x[5] - x[0]));
-    volTube->SetLineColor(kGray);
-
-    Double_t thickness = cableThickness + mcmThickness;
-    TGeoBBox *shOut = new TGeoBBox("ITSSPD_shape_plateout", 0.5*plateThickness, 0.5*plateLength, 0.5*plateWidth);
-    TGeoBBox *shIn = new TGeoBBox("ITSSPD_shape_platein", 0.5*thickness, 0.52*plateLength, 0.5*cableW2);
-    Char_t string[255];
-    sprintf(string, "%s-%s", shOut->GetName(), shIn->GetName());
-    TGeoCompositeShape *shPlate = new TGeoCompositeShape("ITSSPDPlate_shape", string);
-    TGeoVolume *volPlate = new TGeoVolume("ITSSPDPlate", shPlate, medPlate);
-    volPlate->SetLineColor(kRed);
+    // The MCM extender on the cone as a Xtru
+    TGeoBBox *shMCMExt = new TGeoBBox(0.5*kMCMLength,
+                                     0.5*kMCMWidth,
+                                     0.5*kMCMThickness);
 
-    TGeoVolume *volMCMExt = gGeoManager->MakeBox("ITSSPDextenderMCM", medExt, 0.5*mcmThickness, 0.5*mcmLength, 0.5*mcmWidth);
+    TGeoVolume *volMCMExt = new TGeoVolume("ITSSPDExtenderMCM",
+                                          shMCMExt, medExt);
     volMCMExt->SetLineColor(kGreen+3);
 
-    TGeoRotation *rot = new TGeoRotation(*gGeoIdentity);
-    rot->RotateX(90.0);
-    rot->RotateZ(90.0);
-    container[0]->AddNode(volCable, 0, rot);
-
-    TGeoTranslation *combi = new TGeoTranslation(cableThickness + 0.5*mcmThickness, x[0] + 0.5*mcmLength, 0.0);
-    container[0]->AddNode(volMCMExt, 0, combi);
-
-    TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity);
-    rot1->RotateX(87.5);
-    TGeoCombiTrans *tr = new TGeoCombiTrans(1.15, x[0] + 0.5*(x[5] - x[0]), -2.95, rot1);
-    container[1]->AddNode(volTube, 0, tr);
+    // The support plate on the cone as a composite shape
+    Double_t thickness = kCableThickness + kMCMThickness;
+    TGeoBBox *shOut = new TGeoBBox("ITSSPD_shape_plateout",
+                                  0.5*kPlateLength,
+                                  0.5*kPlateWidth,
+                                  0.5*kPlateThickness);
+    TGeoBBox *shIn  = new TGeoBBox("ITSSPD_shape_platein" ,
+                                  0.5*kPlateLength,
+                                  0.5*cableW2,
+                                  0.5*thickness);
+    Char_t string[255];
+    sprintf(string, "%s-%s", shOut->GetName(), shIn->GetName());
+    TGeoCompositeShape *shPlate = new TGeoCompositeShape("ITSSPDPlate_shape",
+                                string);
 
-    TGeoTranslation *tr1 = new TGeoTranslation(0.5*plateThickness - 0.5*(plateThickness-thickness), x[3] - x[0] - 0.52*plateLength, 0.0);
-    container[0]->AddNode(volPlate, 0, tr1);
+    TGeoVolume *volPlate = new TGeoVolume("ITSSPDPlate",
+                                         shPlate, medPlate);
+    volPlate->SetLineColor(kRed);
 
+    // The cooling tube on the cone as a Ctub
+    Double_t tubeLength = shCable->GetX(5) - shCable->GetX(0) + kYtoHalfStave;
+    TGeoCtub *shTube = new TGeoCtub(0, kConeTubeRmax, 0.5*tubeLength, 0, 360,
+                                   0, SinD(angrot/2), -CosD(angrot/2),
+                                   0,              0,              1);
+
+    TGeoVolume *volTubeA = new TGeoVolume("ITSSPDCoolingTubeOnConeA",
+                                         shTube, medInox);
+    volTubeA->SetLineColor(kGray);
+
+    TGeoVolume *volTubeC = new TGeoVolume("ITSSPDCoolingTubeOnConeC",
+                                         shTube, medInox);
+    volTubeC->SetLineColor(kGray);
+
+    // The freon in the cooling tubes on the cone as a Ctub
+    TGeoCtub *shFreon = new TGeoCtub(0, kConeTubeRmin, 0.5*tubeLength, 0, 360,
+                                    0, SinD(angrot/2), -CosD(angrot/2),
+                                    0,              0,              1);
+
+    TGeoVolume *volFreon = new TGeoVolume("ITSSPDCoolingFreonOnCone",
+                                         shFreon, medFreon);
+    volFreon->SetLineColor(kPurple);
+
+    TGeoVolume *volGasFr = new TGeoVolume("ITSSPDCoolingFreonGasOnCone",
+                                         shFreon, medGas);
+    volGasFr->SetLineColor(kPurple);
+
+    // The cooling tube inside the cylinder as a Ctub
+    TGeoCtub *shCylTub = new TGeoCtub(0, kConeTubeRmax,
+                                     0.5*kHorizTubeLen, 0, 360,
+                                     0,            0,           -1,
+                                     0, SinD(angrot/2), CosD(angrot/2));
+
+    TGeoVolume *volCylTubA = new TGeoVolume("ITSSPDCoolingTubeOnCylA",
+                                           shCylTub, medInox);
+    volCylTubA->SetLineColor(kGray);
+
+    TGeoVolume *volCylTubC = new TGeoVolume("ITSSPDCoolingTubeOnCylC",
+                                           shCylTub, medInox);
+    volCylTubC->SetLineColor(kGray);
+
+    // The freon in the cooling tubes in the cylinder as a Ctub
+    TGeoCtub *shCylFr = new TGeoCtub(0, kConeTubeRmin,
+                                    0.5*kHorizTubeLen, 0, 360,
+                                    0,            0,           -1,
+                                    0, SinD(angrot/2), CosD(angrot/2));
+
+    TGeoVolume *volCylFr = new TGeoVolume("ITSSPDCoolingFreonOnCyl",
+                                         shCylFr, medFreon);
+    volCylFr->SetLineColor(kPurple);
+
+    TGeoVolume *volCylGasFr = new TGeoVolume("ITSSPDCoolingFreonGasOnCyl",
+                                            shCylFr, medGas);
+    volCylGasFr->SetLineColor(kPurple);
+
+    // Now place everything in the containers
+    volTubeA->AddNode(volGasFr, 1, 0);
+    volTubeC->AddNode(volFreon, 1, 0);
+
+    volCylTubA->AddNode(volCylGasFr, 1, 0);
+    volCylTubC->AddNode(volCylFr   , 1, 0);
+
+    container[0]->AddNode(volCable, 1, 0);
+
+    xloc = shMCMExt->GetDX();
+    zloc = shMCMExt->GetDZ();
+    container[0]->AddNode(volMCMExt, 1,
+                         new TGeoTranslation( xloc, 0.,-zloc));
+
+    xloc = shMCMExt->GetDX();
+    zloc = shCable->GetZ(1)/2 - shMCMExt->GetDZ();
+    container[0]->AddNode(volPlate, 1,
+                         new TGeoTranslation( xloc, 0., zloc));
+
+    xloc = shTube->GetRmax();
+    yloc = shTube->GetRmax();
+    zloc = shTube->GetDz() - shTube->GetRmax() - kYtoHalfStave;
+    container[1]->AddNode(volTubeA, 1,
+                         new TGeoTranslation(-xloc, -yloc, zloc));
+    container[2]->AddNode(volTubeC, 1,
+                         new TGeoTranslation(-xloc, -yloc, zloc));
+
+    xloc = shTube->GetRmax();
+    yloc = (shCylTub->GetDz())*SinD(angrot) - shTube->GetRmax();
+    zloc = (shCylTub->GetDz())*CosD(angrot) + shTube->GetRmax() +kYtoHalfStave;
+    container[1]->AddNode(volCylTubA, 1,
+                         new TGeoCombiTrans(-xloc, yloc,-zloc,
+                                    new TGeoRotation("",0.,angrot,0.)));
+    container[2]->AddNode(volCylTubC, 1,
+                         new TGeoCombiTrans(-xloc, yloc,-zloc,
+                                    new TGeoRotation("",0.,angrot,0.)));
+
+    // Finally create the list of assemblies and return it to the caller
     TList* conemodulelist = new TList();
-
     conemodulelist->Add(container[0]);
     conemodulelist->Add(container[1]);
+    conemodulelist->Add(container[2]);
 
     return conemodulelist;
 }
@@ -3014,54 +3128,85 @@ TList* AliITSv11GeometrySPD::CreateConeModule(TGeoManager *mgr) const
 //______________________________________________________________________
 void AliITSv11GeometrySPD::CreateCones(TGeoVolume *moth) const
 {
+    //
+    // Places all services modules in the mother reference system
+    //
+    // Created:      ?? ??? 2008  Alberto Pulvirenti
+    // Updated:      03 May 2010  Mario Sitta
+    //
 
-    TList* modulelist = CreateConeModule(gGeoManager);
+    const Int_t kNumberOfModules    =  10;
+
+    const Double_t kInnerRadius     =  80.775*fgkmm;
+    const Double_t kZTrans          = 452.000*fgkmm;
+    const Double_t kAlphaRot        =  46.500*fgkDegree;
+    const Double_t kAlphaSpaceCool  =   8.500*fgkDegree;
+
+    TList* modulelist = CreateConeModule(90-kAlphaRot);
     TGeoVolumeAssembly* module;
 
+    Double_t xloc, yloc, zloc;
+
     //Double_t angle[10] = {18., 54., 90., 126., 162., -18., -54., -90., -126., -162.};
     // angleNm for cone modules (cables), angleNc for cooling tubes
-    Double_t angle1m[10] = {23., 53., 90., 127., 157., 203.0, 233.0, 270.0, 307.0, 337.0};
-    Double_t angle2m[10] = {18., 53., 90., 126., 162., 198.0, 233.0, 270.0, 309.0, 342.0};
-    Double_t angle1c[10] = {23., 53., 90., 124., 157., 203.0, 233.0, 270.0, 304.0, 337.0};
-    Double_t angle2c[10] = {18., 44., 90., 126., 162., 198.0, 223.0, 270.0, 309.0, 342.0};
+    Double_t anglem[10] = {18., 54., 90., 126., 162., 198., 234., 270., 306., 342.};
+//    Double_t angle1m[10] = {23., 53., 90., 127., 157., 203.0, 233.0, 270.0, 307.0, 337.0};
+//    Double_t angle2m[10] = {18., 53., 90., 126., 162., 198.0, 233.0, 270.0, 309.0, 342.0};
+//    Double_t angle1c[10] = {23., 53., 90., 124., 157., 203.0, 233.0, 270.0, 304.0, 337.0};
+//    Double_t angle2c[10] = {18., 44., 90., 126., 162., 198.0, 223.0, 270.0, 309.0, 342.0};
 
     // First add the cables
     module = (TGeoVolumeAssembly*)modulelist->At(0);
-    for (Int_t i = 0; i < 10; i++) {
+    for (Int_t i = 0; i < kNumberOfModules; i++) {
         TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity);
-        rot1->RotateY(-90.0);
-        rot1->RotateX(45.0);
-       angle1m[i] -= 1.5;
-        rot1->RotateZ(90.0 - angle1m[i]);
-        TGeoCombiTrans *tr1 = new TGeoCombiTrans(0.0, 0.0, 38.0, rot1);
-        moth->AddNode(module, 2*i, tr1);
+       rot1->RotateY(-kAlphaRot);
+       rot1->RotateZ(anglem[i]);
+        xloc = kInnerRadius*CosD(anglem[i]);
+        yloc = kInnerRadius*SinD(anglem[i]);
+       zloc = kZTrans;
+        moth->AddNode(module, 2*i,
+                     new TGeoCombiTrans( xloc, yloc, zloc, rot1));
+
         TGeoRotation *rot2 = new TGeoRotation(*gGeoIdentity);
-        rot2->RotateY(90.0);
-        rot2->RotateX(-45.0);
-       angle2m[i] -= 1.5;
-        rot2->RotateZ(90.0 - angle2m[i]);
-        TGeoCombiTrans *tr2 = new TGeoCombiTrans(0.0, 0.0, -37.9, rot2);
-        moth->AddNode(module, 2*i+1, tr2);
+       rot2->RotateY(180.-kAlphaRot);
+       rot2->RotateZ(anglem[i]);
+        xloc = kInnerRadius*CosD(anglem[i]);
+        yloc = kInnerRadius*SinD(anglem[i]);
+       zloc = kZTrans;
+        moth->AddNode(module, 2*i+1,
+                     new TGeoCombiTrans(-xloc,-yloc,-zloc, rot2));
     }
 
-    // Then the cooling tubes
+    // Then the cooling tubes on Side A
     module = (TGeoVolumeAssembly*)modulelist->At(1);
-    for (Int_t i = 0; i < 10; i++) {
+    Double_t anglec;
+    for (Int_t i = 0; i < kNumberOfModules; i++) {
+        anglec = anglem[i] + kAlphaSpaceCool;
         TGeoRotation *rot1 = new TGeoRotation(*gGeoIdentity);
-        rot1->RotateY(-90.0);
-        rot1->RotateX(45.0);
-       angle1c[i] -= 1.5;
-        rot1->RotateZ(90.0 - angle1c[i]);
-        TGeoCombiTrans *tr1 = new TGeoCombiTrans(0.0, 0.0, 38.0, rot1);
-        moth->AddNode(module, 2*i, tr1);
+        rot1->RotateX(-90.0+kAlphaRot);
+       rot1->RotateZ(-90+anglec);
+        xloc = kInnerRadius*CosD(anglec);
+        yloc = kInnerRadius*SinD(anglec);
+       zloc = kZTrans;
+        moth->AddNode(module, 2*i, 
+                     new TGeoCombiTrans( xloc, yloc, zloc, rot1));
+    }
+
+    // Finally the cooling tubes on Side C
+    module = (TGeoVolumeAssembly*)modulelist->At(2);
+    for (Int_t i = 0; i < kNumberOfModules; i++) {
+        anglec = anglem[i] - kAlphaSpaceCool;
         TGeoRotation *rot2 = new TGeoRotation(*gGeoIdentity);
-        rot2->RotateY(90.0);
-        rot2->RotateX(-45.0);
-       angle2c[i] -= 1.5;
-        rot2->RotateZ(90.0 - angle2c[i]);
-        TGeoCombiTrans *tr2 = new TGeoCombiTrans(0.0, 0.0, -37.9, rot2);
-        moth->AddNode(module, 2*i+1, tr2);
+        rot2->RotateX(-90.0+kAlphaRot);
+       rot2->RotateY(180.);
+       rot2->RotateZ(90.+anglec);
+        xloc = kInnerRadius*CosD(anglec);
+        yloc = kInnerRadius*SinD(anglec);
+       zloc = kZTrans;
+        moth->AddNode(module, 2*i+1,
+                     new TGeoCombiTrans(-xloc,-yloc,-zloc, rot2));
     }
+
 }
 
 //______________________________________________________________________
index 4fa85f3..9d9c407 100644 (file)
@@ -110,7 +110,8 @@ class AliITSv11GeometrySPD : public AliITSv11Geometry
     virtual TGeoVolumeAssembly* CreatePixelBusAndExtensions(Bool_t zpos=kTRUE,
                                         TGeoManager *mgr = gGeoManager) const;
 
-    virtual TList* CreateConeModule(TGeoManager *mgr = gGeoManager) const;
+    virtual TList* CreateConeModule(const Double_t angle,
+                                   TGeoManager *mgr = gGeoManager) const;
     virtual void CreateCones(TGeoVolume *moth) const;
     // a half-stave (put together ladders + MCM + bus, and add clips
     // if requested)
index 13fafaf..cd65af0 100644 (file)
@@ -789,6 +789,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
+// Updated:      10 Jun 2010  Mario Sitta   Cables across cone holes added
 //
 // Technical data are taken from:  "Supporto Generale Settore SDD"
 // (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
@@ -829,7 +830,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   const Double_t kTanConeTheta       =
                                      TMath::Tan(kConeTheta*TMath::DegToRad());
   // Dimensions of the Cone Inserts
-  const Double_t kConeCFThickness       = 1.5*fgkmm; // Carbon fiber thickness
+  const Double_t kConeCFThickness    =       1.5*fgkmm;//Carbon fiber thickness
   // Dimensions of the Cone Holes
   const Double_t kHole1RMin          = (450.0/2)*fgkmm;
   const Double_t kHole1RMax          = (530.0/2)*fgkmm;
@@ -845,17 +846,24 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   const Double_t kHole4DeltaR        =        15*fgkmm;
   const Double_t kHole4Width         =        30*fgkmm;
   //  const Int_t    kNHole4             =         3      ;
+  // Fraction of materials in holes
+  const Double_t kHolePlasticFrac    =       0.55846;
+  const Double_t kHoleCuFrac         =       0.06319;
+  const Double_t kHoleGlassFrac      =       0.02652;
 
   // Local variables
   Double_t x, y, z, t, dza, rmin, rmax;
 
 
   // Recover the needed materials
-  TGeoMedium *medSDDcf  = mgr->GetMedium("ITS_SDD C (M55J)$");
-  TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
-  TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
-  TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
-  TGeoMedium *medSDDss  = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medSDDcf    = mgr->GetMedium("ITS_SDD C (M55J)$");
+  TGeoMedium *medSDDair   = mgr->GetMedium("ITS_SDD AIR$");
+  TGeoMedium *medSDDste   = mgr->GetMedium("ITS_G10FR4$"); // stesalite
+  TGeoMedium *medSDDroh   = mgr->GetMedium("ITS_ROHACELL$");
+  TGeoMedium *medSDDss    = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+  TGeoMedium *medSDDCu    = mgr->GetMedium("ITS_COPPER$");
+  TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");
 
   // First define the geometrical shapes
 
@@ -1358,6 +1366,143 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   hole4shape->Z(3)    = ZFromRmaxpCone(coneshape,4,kConeTheta,
                                       hole4shape->GetRmax(3));
 
+  // Cables to be put inside the holes: Pcon's
+  // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
+  TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+  hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
+  hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
+  hole1plastshape->Z(0)    = hole1shape->GetZ(0);
+
+  hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
+  hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
+  hole1plastshape->Z(1)    = hole1shape->GetZ(1);
+
+  dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;
+
+  hole1plastshape->Rmin(2) = dza;
+  hole1plastshape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                           hole1plastshape->GetRmin(2));
+  hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
+                                           hole1plastshape->GetZ(2));
+
+  hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
+  hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
+  hole1plastshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                           hole1plastshape->GetRmax(3));
+
+  TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+  hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
+  hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
+  hole1Cushape->Z(0)    = hole1plastshape->GetZ(2);
+
+  dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;
+
+  hole1Cushape->Rmin(1) = dza;
+  hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
+  hole1Cushape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                        hole1Cushape->GetRmin(1));
+
+  hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
+  hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
+  hole1Cushape->Z(2)    = hole1plastshape->GetZ(3);
+
+  hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
+  hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
+  hole1Cushape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                        hole1Cushape->GetRmax(3));
+
+  TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+  hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
+  hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
+  hole1glassshape->Z(0)    = hole1Cushape->GetZ(1);
+
+  dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;
+
+  hole1glassshape->Rmin(1) = dza;
+  hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
+  hole1glassshape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                           hole1glassshape->GetRmin(1));
+
+  hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
+  hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
+  hole1glassshape->Z(2)    = hole1Cushape->GetZ(3);
+
+  hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
+  hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
+  hole1glassshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                           hole1glassshape->GetRmax(3));
+  //
+  TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+  hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
+  hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
+  hole2plastshape->Z(0)    = hole2shape->GetZ(0);
+
+  hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
+  hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
+  hole2plastshape->Z(1)    = hole2shape->GetZ(1);
+
+  dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;
+
+  hole2plastshape->Rmin(2) = dza;
+  hole2plastshape->Z(2)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                           hole2plastshape->GetRmin(2));
+  hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
+                                           hole2plastshape->GetZ(2));
+
+  hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
+  hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
+  hole2plastshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                           hole2plastshape->GetRmax(3));
+
+  TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+  hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
+  hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
+  hole2Cushape->Z(0)    = hole2plastshape->GetZ(2);
+
+  dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;
+
+  hole2Cushape->Rmin(1) = dza;
+  hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
+  hole2Cushape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                        hole2Cushape->GetRmin(1));
+
+  hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
+  hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
+  hole2Cushape->Z(2)    = hole2plastshape->GetZ(3);
+
+  hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
+  hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
+  hole2Cushape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                        hole2Cushape->GetRmax(3));
+
+  TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+  hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
+  hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
+  hole2glassshape->Z(0)    = hole2Cushape->GetZ(1);
+
+  dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;
+
+  hole2glassshape->Rmin(1) = dza;
+  hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
+  hole2glassshape->Z(1)    = ZFromRminpCone(conefoamshape,1,kConeTheta,
+                                           hole2glassshape->GetRmin(1));
+
+  hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
+  hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
+  hole2glassshape->Z(2)    = hole2Cushape->GetZ(3);
+
+  hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
+  hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
+  hole2glassshape->Z(3)    = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+                                           hole2glassshape->GetRmax(3));
+
+
   // Debug if requested
   if (GetDebug(1)) {
     coneshape->InspectShape();
@@ -1420,6 +1565,30 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   hole12->SetFillColor(hole12->GetLineColor());
   hole12->SetFillStyle(4090); // 90% transparent
 
+  TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
+                                         hole1plastshape,medSDDplast);
+  hole1plast->SetVisibility(kTRUE);
+  hole1plast->SetLineColor(kBlue);
+  hole1plast->SetLineWidth(1);
+  hole1plast->SetFillColor(hole1plast->GetLineColor());
+  hole1plast->SetFillStyle(4090); // 90% transparent
+
+  TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
+                                      hole1Cushape,medSDDCu);
+  hole1Cu->SetVisibility(kTRUE);
+  hole1Cu->SetLineColor(kRed);
+  hole1Cu->SetLineWidth(1);
+  hole1Cu->SetFillColor(hole1Cu->GetLineColor());
+  hole1Cu->SetFillStyle(4090); // 90% transparent
+
+  TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
+                                         hole1glassshape,medSDDglass);
+  hole1glass->SetVisibility(kTRUE);
+  hole1glass->SetLineColor(kGreen);
+  hole1glass->SetLineWidth(1);
+  hole1glass->SetFillColor(hole1glass->GetLineColor());
+  hole1glass->SetFillStyle(4090); // 90% transparent
+
   TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
                                     hole2shape,medSDDair);
   hole2->SetVisibility(kTRUE);
@@ -1444,6 +1613,30 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   hole22->SetFillColor(hole22->GetLineColor());
   hole22->SetFillStyle(4090); // 90% transparent
 
+  TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
+                                         hole2plastshape,medSDDplast);
+  hole2plast->SetVisibility(kTRUE);
+  hole2plast->SetLineColor(kBlue);
+  hole2plast->SetLineWidth(1);
+  hole2plast->SetFillColor(hole2plast->GetLineColor());
+  hole2plast->SetFillStyle(4090); // 90% transparent
+
+  TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
+                                      hole2Cushape,medSDDCu);
+  hole2Cu->SetVisibility(kTRUE);
+  hole2Cu->SetLineColor(kRed);
+  hole2Cu->SetLineWidth(1);
+  hole2Cu->SetFillColor(hole2Cu->GetLineColor());
+  hole2Cu->SetFillStyle(4090); // 90% transparent
+
+  TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
+                                         hole2glassshape,medSDDglass);
+  hole2glass->SetVisibility(kTRUE);
+  hole2glass->SetLineColor(kGreen);
+  hole2glass->SetLineWidth(1);
+  hole2glass->SetFillColor(hole2glass->GetLineColor());
+  hole2glass->SetFillStyle(4090); // 90% transparent
+
   TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
                                     hole3shape,medSDDair);
   hole3->SetVisibility(kTRUE);
@@ -1479,6 +1672,14 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
   // Mount up a cone
   cfconeinsert->AddNode(cfconefoam,1,0);
 
+  hole1->AddNode(hole1plast, 1, 0);
+  hole1->AddNode(hole1Cu, 1, 0);
+  hole1->AddNode(hole1glass, 1, 0);
+
+  hole2->AddNode(hole2plast, 1, 0);
+  hole2->AddNode(hole2Cu, 1, 0);
+  hole2->AddNode(hole2glass, 1, 0);
+
   for (Int_t i=0; i<12; i++) {
     Double_t phiH = i*30.0;
     cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
@@ -3141,6 +3342,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
 // Output:
 //
 // Created:      15 Feb 2010  Mario Sitta
+// Updated:      10 Jun 2010  Mario Sitta  Freon inside cooling pipes
 //
 // Technical data are taken from AutoCAD drawings, L.Simonetti technical
 // drawings and other (oral) information given by F.Tosello and D.Elia
@@ -3182,6 +3384,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
 
   const Double_t kOpticalFibersSect      =    8.696*fgkmm;//!!!ESTIMATED!!!
   const Double_t kLowVoltageCableSect    =    3.412*fgkmm;//!!!ESTIMATED!!!
+  const Double_t kHiVoltageCableSect     =    1.873*fgkmm;//!!!ESTIMATED!!!
+
 
   // Local variables
   Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
@@ -3262,19 +3466,27 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
                                 (kForwardTrayInterSpace-kExternalTrayThick)/2,
                                       kExternalTrayLen/2);
 
-  // The cooling tube inside the forward tray: a TubeSeg
+  // The cooling tube inside the forward tray: a Tube
   Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
                - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
   Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
-  TGeoTubeSeg *coolTubeForw = new TGeoTubeSeg(kCoolingTubeRmin,
-                                             kCoolingTubeRmax, zlen, 0, 360);
+  TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
+
+  // The freon inside the forward tray tubes: a Tube
+  TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
 
   // The cooling tube inside the external tray: a Ctub
-  TGeoCtub *coolTubeExt = new TGeoCtub(kCoolingTubeRmin, kCoolingTubeRmax,
+  TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
                                       kExternalTrayLen/2, 0, 360,
                                       0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
                                       0,                0,               1);
 
+  // The freon inside the forward tray tubes: a Tube
+  TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
+                                       kExternalTrayLen/2, 0, 360,
+                                       0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
+                                       0,                0,               1);
+
   // The optical fibers inside the forward tray: a BBox
   TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2,
                                       kOpticalFibersSect/2,
@@ -3321,12 +3533,37 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   lowCablesExt->DefineSection(0, 0);
   lowCablesExt->DefineSection(1, kLowVoltageCableSect);
 
+  // The High Voltage cables inside the forward tray: a BBox
+  TGeoBBox *hiCablesForw = new TGeoBBox(kHiVoltageCableSect/2,
+                                       kHiVoltageCableSect/2,
+                                       kForwardTrayTotalLen/2);
+
+  // The High Voltage inside the external tray: a Xtru
+  TGeoXtru *hiCablesExt = new TGeoXtru(2);
+  hiCablesExt->SetName("ITSsuppSPDExtTrayHiVoltage");
+
+  yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+          + 2*forwTrayWall->GetDY();
+  xprof[0] = yprof[0]*TanD(kTrayAZRot);
+  xprof[1] = kExternalTrayLen;
+  yprof[1] = yprof[0];
+  xprof[2] = xprof[1];
+  yprof[2] = yprof[1] + kHiVoltageCableSect;
+  yprof[3] = yprof[2];
+  xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+  hiCablesExt->DefinePolygon(4, xprof, yprof);
+  hiCablesExt->DefineSection(0, 0);
+  hiCablesExt->DefineSection(1, kHiVoltageCableSect);
+
 
   // We have all shapes: now create the real volumes
-  TGeoMedium *medAl   = mgr->GetMedium("ITS_ALUMINUM$");
-  TGeoMedium *medIn   = mgr->GetMedium("ITS_INOX$");
-  TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
-  TGeoMedium *medLVC  = mgr->GetMedium("ITS_SPD_LOWCABLES$");
+  TGeoMedium *medAl    = mgr->GetMedium("ITS_ALUMINUM$");
+  TGeoMedium *medIn    = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
+  TGeoMedium *medFibs  = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
+  TGeoMedium *medLVC   = mgr->GetMedium("ITS_SPD_LOWCABLES$");
+  TGeoMedium *medHVC   = mgr->GetMedium("ITS_SPD_HICABLES$");
 
   TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
                                            forwTrayLowerFace, medAl);
@@ -3427,6 +3664,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
   forwCoolTube->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
+                                            freonTubeForw, medFreon);
+
+  forwCoolFreon->SetVisibility(kTRUE);
+  forwCoolFreon->SetLineColor(kBlue); // Blue
+  forwCoolFreon->SetLineWidth(1);
+  forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
+  forwCoolFreon->SetFillStyle(4000); // 0% transparent
+
   TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
                                           coolTubeExt, medIn);
 
@@ -3436,6 +3682,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   extCoolTube->SetFillColor(extCoolTube->GetLineColor());
   extCoolTube->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
+                                           freonTubeExt, medFreon);
+
+  extCoolFreon->SetVisibility(kTRUE);
+  extCoolFreon->SetLineColor(kBlue); // Blue
+  extCoolFreon->SetLineWidth(1);
+  extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
+  extCoolFreon->SetFillStyle(4000); // 0% transparent
+
   TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
                                           optFibsForw, medFibs);
 
@@ -3472,6 +3727,24 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   extLowCabs->SetFillColor(extLowCabs->GetLineColor());
   extLowCabs->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *forwHiCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabs",
+                                         hiCablesForw, medHVC);
+
+  forwHiCabs->SetVisibility(kTRUE);
+  forwHiCabs->SetLineColor(kRed); // Red
+  forwHiCabs->SetLineWidth(1);
+  forwHiCabs->SetFillColor(forwHiCabs->GetLineColor());
+  forwHiCabs->SetFillStyle(4000); // 0% transparent
+
+  TGeoVolume *extHiCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabs",
+                                        hiCablesExt, medHVC);
+
+  extHiCabs->SetVisibility(kTRUE);
+  extHiCabs->SetLineColor(kRed); // Red
+  extHiCabs->SetLineWidth(1);
+  extHiCabs->SetFillColor(extHiCabs->GetLineColor());
+  extHiCabs->SetFillStyle(4000); // 0% transparent
+
 
   // Now build up the trays
   yloc = forwTrayLowerFace->GetDY();
@@ -3515,6 +3788,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   cableTrayAForw->AddNode(forwTrayAWall, 1,
                      new TGeoTranslation(0, yloc, zloc));
 
+  forwCoolTube->AddNode(forwCoolFreon, 1, 0);
+
   yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
        + coolTubeForw->GetRmax();
   zloc = coolTubeForw->GetDz();
@@ -3533,6 +3808,13 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   cableTrayAForw->AddNode(forwLowCabs, 1,
                      new TGeoTranslation(-xloc, yloc, zloc));
 
+  xloc = hiCablesForw->GetDX() + 2*lowCablesForw->GetDX()
+       + coolTubeForw->GetRmax();
+  yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + hiCablesForw->GetDY();
+  zloc = hiCablesForw->GetDZ();
+  cableTrayAForw->AddNode(forwHiCabs, 1,
+                     new TGeoTranslation(-xloc, yloc, zloc));
+
   // To simplify following placement in MARS, origin is on top
   yloc = -kExternalTrayHigh + kExternalTrayThick/2;
   zloc = kExternalTrayLen/2;
@@ -3559,6 +3841,8 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
   cableTrayAExt->AddNode(extTrayAWall, 1,
                      new TGeoTranslation( 0, yloc, zloc));
 
+  extCoolTube->AddNode(extCoolFreon, 1, 0);
+
   yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
        + coolTubeExt->GetRmax();
   zloc = coolTubeExt->GetDz();
@@ -3575,6 +3859,11 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
                      new TGeoCombiTrans(-xloc, 0, 0,
                                         new TGeoRotation("",90,-90,-90)));
 
+  xloc = 2*kHiVoltageCableSect + kLowVoltageCableSect + coolTubeExt->GetRmax();
+  cableTrayAExt->AddNode(extHiCabs, 1,
+                     new TGeoCombiTrans(-xloc, 0, 0,
+                                        new TGeoRotation("",90,-90,-90)));
+
 
   // Finally put everything in the mother volume
   Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
@@ -3712,6 +4001,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
 //
 // Created:         ???       Bjorn S. Nilsen
 // Updated:      22 Apr 2010  Mario Sitta
+// Updated:      10 Jun 2010  Mario Sitta  Freon inside cooling pipes
 //
 // Technical data are taken from AutoCAD drawings and other (oral)
 // information given by D.Elia
@@ -3734,6 +4024,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   const Double_t kCoolingTubeRmax     =    6.000 *fgkmm;
   const Double_t kOpticalFibersSect   =    8.696 *fgkmm;//!!!ESTIMATED!!!
   const Double_t kLowVoltageCableSect =    3.412 *fgkmm;//!!!ESTIMATED!!!
+  const Double_t kHiVoltageCableSect  =    1.873 *fgkmm;//!!!ESTIMATED!!!
 
   // Overall position and rotation of the C-Side Cable Trays
   const Double_t kTraySideCRPos       =   45.300 *fgkcm;
@@ -3871,8 +4162,10 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
 
   // The horizontal part of the cooling tube inside the tray: a Tube
   delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
-  TGeoTube *horTube = new TGeoTube(kCoolingTubeRmin, kCoolingTubeRmax,
-                                  delta/2);
+  TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
+
+  // The freon inside the horizontal part of the cooling tube: a Tube
+  TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
 
   // The inclined part of the cooling tube inside the tray: a Ctub
   Double_t x3, y3, x4, y4;
@@ -3885,8 +4178,12 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
        (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
        (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
 
-  TGeoCtub *incTube = new TGeoCtub(kCoolingTubeRmin, kCoolingTubeRmax,
-                                  delta/2, 0, 360,
+  TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
+                              0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
+                              0,                     0,                    1);
+
+  // The freon inside the inclined part of the cooling tube: a Ctub
+  TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
                               0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
                               0,                     0,                    1);
 
@@ -3894,7 +4191,6 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   TGeoXtru *optFibs = new TGeoXtru(2);
 
   xprof[0] = sideCMidFace->GetX(5);
-
   yprof[0] = sideCMidFace->GetY(5);
   xprof[1] = sideCMidFace->GetX(4);
   yprof[1] = sideCMidFace->GetY(4);
@@ -3931,12 +4227,34 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   lowCables->DefineSection(0, 0);
   lowCables->DefineSection(1, kLowVoltageCableSect);
 
+  // The high voltage cables inside the tray: a Xtru
+  TGeoXtru *hiCables = new TGeoXtru(2);
+
+  xprof[0] = sideCMidFace->GetX(5);
+  yprof[0] = sideCMidFace->GetY(5);
+  xprof[1] = sideCMidFace->GetX(4);
+  yprof[1] = sideCMidFace->GetY(4);
+  xprof[2] = sideCMidFace->GetX(3);
+  yprof[2] = sideCMidFace->GetY(3);
+  xprof[3] = xprof[2] - kHiVoltageCableSect*SinD(kTrayCFoldAngle);
+  yprof[3] = yprof[2] + kHiVoltageCableSect*CosD(kTrayCFoldAngle);
+  InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+             kHiVoltageCableSect , xprof[4], yprof[4]);
+  xprof[5] = 0.;
+  yprof[5] = yprof[0] + kHiVoltageCableSect;
+
+  hiCables->DefinePolygon(6, xprof, yprof);
+  hiCables->DefineSection(0, 0);
+  hiCables->DefineSection(1, kHiVoltageCableSect);
+
 
   // We have all shapes: now create the real volumes
   TGeoMedium *medAl   = mgr->GetMedium("ITS_ALUMINUM$");
   TGeoMedium *medIn   = mgr->GetMedium("ITS_INOX$");
+  TGeoMedium *medFr   = mgr->GetMedium("ITS_Freon$");
   TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
   TGeoMedium *medLVC  = mgr->GetMedium("ITS_SPD_LOWCABLES$");
+  TGeoMedium *medHVC  = mgr->GetMedium("ITS_SPD_HICABLES$");
 
   TGeoVolume *traySideCHorFace  = new TGeoVolume("ITSsuppSPDTraySideCHor",
                                                 sideCHorFace, medAl);
@@ -4001,6 +4319,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
   traySideCHorTube->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
+                                                horFreon, medFr);
+
+  traySideCHorFreon->SetVisibility(kTRUE);
+  traySideCHorFreon->SetLineColor(kBlue); // Blue
+  traySideCHorFreon->SetLineWidth(1);
+  traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
+  traySideCHorFreon->SetFillStyle(4000); // 0% transparent
+
   TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
                                                incTube, medIn);
 
@@ -4010,6 +4337,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
   traySideCIncTube->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
+                                                incFreon, medFr);
+
+  traySideCIncFreon->SetVisibility(kTRUE);
+  traySideCIncFreon->SetLineColor(kBlue); // Blue
+  traySideCIncFreon->SetLineWidth(1);
+  traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
+  traySideCIncFreon->SetFillStyle(4000); // 0% transparent
+
   TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
                                                optFibs, medFibs);
 
@@ -4028,6 +4364,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   traySideCLowCabs->SetFillColor(traySideCLowCabs->GetLineColor());
   traySideCLowCabs->SetFillStyle(4000); // 0% transparent
 
+  TGeoVolume *traySideCHiCabs = new TGeoVolume("ITSsuppSPDTraySideCHiCabs",
+                                              hiCables, medHVC);
+
+  traySideCHiCabs->SetVisibility(kTRUE);
+  traySideCHiCabs->SetLineColor(kRed); // Red
+  traySideCHiCabs->SetLineWidth(1);
+  traySideCHiCabs->SetFillColor(traySideCHiCabs->GetLineColor());
+  traySideCHiCabs->SetFillStyle(4000); // 0% transparent
+
 
   // Now build up the trays
   cableTrayC->AddNode(traySideCHorFace,1,0);
@@ -4050,6 +4395,9 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
 
   cableTrayC->AddNode(traySideCIntWall,1,0);
 
+  traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
+  traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
+
   xloc = horTube->GetDz();
   yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
   cableTrayC->AddNode(traySideCHorTube, 1,
@@ -4071,6 +4419,10 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
   cableTrayC->AddNode(traySideCLowCabs, 1,
                      new TGeoTranslation( 0, 0,-zloc));
 
+  zloc = kHiVoltageCableSect + kLowVoltageCableSect + horTube->GetRmax();
+  cableTrayC->AddNode(traySideCHiCabs, 1,
+                     new TGeoTranslation( 0, 0,-zloc));
+
 
   // Finally put everything in the mother volume
   for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
@@ -4356,8 +4708,13 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
 
 
   // The assembly holding the metallic structure
-  TGeoVolumeAssembly *trayStructure =
-                               CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
+  // We need four of them because the content is different
+  TGeoVolumeAssembly *trayStructure[kNumTraySideC];
+  for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
+    char name[20];
+    sprintf(name,"ITSsupportSDDTrayC%d",jt);
+    trayStructure[jt] = CreateSDDSSDTraysSideC(name);
+  }
 
 
   // We have all shapes: now create the real volumes
@@ -4371,7 +4728,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
     alpharot = kTraySideCAlphaRot[jt];
     xloc = kTraySideCRPos*SinD(alpharot);
     yloc = kTraySideCRPos*CosD(alpharot);
-    moth->AddNode(trayStructure,jt+1,
+    moth->AddNode(trayStructure[jt],1,
                       new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
                       new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
   }
index 213c17a..54aab89 100644 (file)
@@ -5503,6 +5503,10 @@ void AliITSv11Hybrid::CreateMaterials(){
     AliMixture(56, "SPD KAPTON(POLYCH2)", aKapton, zKapton, dKapton, 4, wKapton);
     AliMedium(56,"SPD KAPTON(POLYCH2)$",56,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
 
+    // Gaseous Freon has same chemical composition but air density at 1.7 atm
+    AliMixture(59,"GASEOUS FREON$",afre,zfre,1.7*dAir,-2,wfre);
+    AliMedium(59,"GASEOUS FREON$",59,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
+
     AliMixture(61,"EPOXY$",aEpoxy,zEpoxy,dEpoxy,-3,wEpoxy);
     AliMedium(61,"EPOXY$",61,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
 
@@ -5798,6 +5802,27 @@ void AliITSv11Hybrid::CreateMaterials(){
     AliMedium(60,"SPD_LOWCABLES$",60,0,ifield,fieldm,tmaxfd,stemax,
              deemax,epsil,stmin);
 
+    // Mean material for high-voltage cables on SPD trays Side A & C
+    // (Copper + HD PolyEthylene (C2-H2)) (D.Elia for cable number and
+    // cross-section area, M.Sitta for elemental computation) - 10 Jun 10
+    wW[0] = 0.083766;//H
+    wW[2] = 0.417136;//Cu
+    wW[1] = 0.499098;//C
+    wW[3] = 0.000000;//O
+    wW[4] = 0.000000;//S
+    wW[5] = 0.000000;//F
+    wW[6] = 0.000000;//Sn
+    wW[7] = 0.000000;//Pb
+    wW[8] = 0.000000;//Cr
+    wW[9] = 0.000000;//Si
+    wW[10] = 0.000000;//Ni
+    wW[11] = 0.000000;//Ca
+
+    den = 1.514930;
+    AliMixture(58,"SPD_HICABLES$",aA,zZ,den,+3,wW);
+    AliMedium(58,"SPD_HICABLES$",58,0,ifield,fieldm,tmaxfd,stemax,
+             deemax,epsil,stmin);
+
     // PolyUrethane [C25-H42-N2-O6] - 07 Mar 10
     zZ[2] =  7.0; aA[2] =  14.0067; // Nitrogen - From Root TGeoElementTable