ITS/AliITSv11GeometrySDD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 //*************************************************************************
  18 //
  19 // SDD geometry, based on ROOT geometrical modeler
  20 //
  21 //
  22 // This geometry has no dependence with aliroot, you can run it with root
  23 // only, provided that the AliITSv11GeomCable classes are also compiled
  24 //
  25 // Ludovic Gaudichet                                   gaudichet@to.infn.it
  26 //*************************************************************************
  27
  28
  29 // $Id$
  30
  31
  32 // General Root includes
  33 #include <TMath.h>
  34
  35 // Root Geometry includes
  36 #include <TGeoManager.h>
  37 #include <TGeoVolume.h>
  38 #include <TGeoCone.h>
  39 #include <TGeoTube.h>
  40 #include <TGeoTrd1.h>
  41 #include <TGeoArb8.h>
  42 #include <TGeoXtru.h>
  43 #include <TGeoCompositeShape.h>
  44 #include <TGeoMatrix.h>
  45 #include <TGeoNode.h>
  46 #include <TGeoPcon.h>
  47 #include <TGeoTorus.h>
  48
  49 #include "AliITSgeom.h"
  50 #include "AliITSgeomSDD.h"
  51 #include "AliITSv11GeometrySDD.h"
  52 #include "AliITSv11GeomCableFlat.h"
  53 #include "AliITSv11GeomCableRound.h"
  54
  55 const char*    AliITSv11GeometrySDD::fgSDDsensitiveVolName3 = "ITSsddSensitivL3";
  56 const char*    AliITSv11GeometrySDD::fgSDDsensitiveVolName4 = "ITSsddSensitivL4";
  57 const Double_t AliITSv11GeometrySDD::fgkSegmentLength     = 37.21*2*fgkmm;
  58 const Double_t AliITSv11GeometrySDD::fgkLadderWidth       = 50.0*fgkmm;
  59 const Double_t AliITSv11GeometrySDD::fgkLadderHeight      = 30.0*fgkmm;
  60 const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDW    =  7.5*fgkmm;
  61 const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH    =  7.1*fgkmm;
  62 const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDHCorr=  2.1*fgkmm;
  63
  64 const Double_t AliITSv11GeometrySDD::fgkLadderBeamRadius  =  0.6*fgkmm;
  65 const Double_t AliITSv11GeometrySDD::fgkLadderLa          =  3.*fgkmm;
  66 const Double_t AliITSv11GeometrySDD::fgkLadderHa          =  0.721979*fgkmm;
  67 const Double_t AliITSv11GeometrySDD::fgkLadderLb          =  3.7*fgkmm;
  68 const Double_t AliITSv11GeometrySDD::fgkLadderHb          =  0.890428*fgkmm;
  69 const Double_t AliITSv11GeometrySDD::fgkLadderl           =  0.25*fgkmm;
  70
  71 const Double_t AliITSv11GeometrySDD::fgkBottomBeamAngle   = 56.5;
  72 const Double_t AliITSv11GeometrySDD::fgkBeamSidePhi       = 65;
  73
  74 const Double_t AliITSv11GeometrySDD::fgkLadWaferSep       = 2*fgkmm;
  75 const Double_t AliITSv11GeometrySDD::fgkPinSuppWidth      = 2.5*fgkmm;
  76 const Double_t AliITSv11GeometrySDD::fgkPinSuppHeight     = 2.*fgkmm;
  77 const Double_t AliITSv11GeometrySDD::fgkPinSuppRmax       = 2.5/2.*fgkmm;
  78 const Double_t AliITSv11GeometrySDD::fgkPinR              = 1.5/2.*fgkmm;
  79 const Double_t AliITSv11GeometrySDD::fgkPinSuppLength     = 5.*fgkmm;
  80 const Double_t AliITSv11GeometrySDD::fgkPinSuppThickness  = 0.5*fgkmm;
  81 const Double_t AliITSv11GeometrySDD::fgkPinSuppConeAngle  = 4;
  82 const Double_t AliITSv11GeometrySDD::fgkPinDXminOnSensor  = (39./2.)*fgkmm;
  83 const Double_t AliITSv11GeometrySDD::fgkPinPinDDXOnSensor = 3*fgkmm;
  84 const Double_t AliITSv11GeometrySDD::fgkPinDYOnSensor     = (52.5/2.)*fgkmm;
  85
  86 // parameters from ALR-0752/3
  87 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHeight    =  3.2*fgkmm;
  88 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppMaxLength = 14*fgkmm;
  89 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthExt  =  0.4*fgkmm;
  90 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthIn   =  0.65*fgkmm;
  91 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHoleDiam  =  2*fgkmm;
  92 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppFulWidth  =  5.15*fgkmm;
  93 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppTongW     =  0.8*fgkmm;
  94 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAngle     = 22.5;
  95 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppSlitL     =  4.9*fgkmm;
  96 const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAxeDist   =  3.05*fgkmm;
  97 const Double_t AliITSv11GeometrySDD::fgkCoolPipeInnerDiam     =  1.84*fgkmm;
  98 const Double_t AliITSv11GeometrySDD::fgkCoolPipeOuterDiam     =  2.*fgkmm;
  99
 100 const Double_t AliITSv11GeometrySDD::fgkBTBthick           =  0.25 *fgkmm;
 101 const Double_t AliITSv11GeometrySDD::fgkBTBlength          = 55. *fgkmm;
 102 const Double_t AliITSv11GeometrySDD::fgkBTBwidth           = 18*fgkmm;
 103 const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBottom   =  4*fgkmm;
 104 const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBase     =  1.2*fgkmm;
 105 const Double_t AliITSv11GeometrySDD::fgkRadiusAminBTB      =  1. *fgkmm;
 106 const Double_t AliITSv11GeometrySDD::fgkRadiusBminBTB      =  0.53 *fgkmm;
 107 const Double_t AliITSv11GeometrySDD::fgkBTBHoleLength      = 15 *fgkmm;
 108 const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth       =  6 *fgkmm;
 109 const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX        = 10 *fgkmm;
 110 const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY        =  6.5 *fgkmm;
 111
 112 const Double_t AliITSv11GeometrySDD::fgkLay3Rmin           = 129.*fgkmm;
 113 const Double_t AliITSv11GeometrySDD::fgkLay3Rmax           = 205.*fgkmm;
 114 const Double_t AliITSv11GeometrySDD::fgkLay3Length         = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
 115 const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength   = 524.*fgkmm;
 116 const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm;
 117 const Double_t AliITSv11GeometrySDD::fgkLay3DetLongRadius  = 152.0*fgkmm;
 118 const Double_t AliITSv11GeometrySDD::fgkLay3LaddTopCornerEnd = 15.6*fgkmm;
 119 const Int_t    AliITSv11GeometrySDD::fgkLay3Ndet           =  6;
 120 const Int_t    AliITSv11GeometrySDD::fgkLay3Nladd          = 14;
 121 const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH  =  7.5*fgkmm;
 122
 123 const Double_t AliITSv11GeometrySDD::fgkLay4Rmin           = 220.*fgkmm;
 124 const Double_t AliITSv11GeometrySDD::fgkLay4Rmax           = 291.*fgkmm;
 125 const Double_t AliITSv11GeometrySDD::fgkLay4Length         = (671.+0.)*fgkmm;    // ladder+supporting rings (length of the virtual tube)
 126 const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength   = 671.*fgkmm;
 127 const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm;
 128 const Double_t AliITSv11GeometrySDD::fgkLay4DetLongRadius  = 240.5*fgkmm;
 129 const Double_t AliITSv11GeometrySDD::fgkLay4LaddTopCornerEnd = 15.6*fgkmm;
 130 const Int_t    AliITSv11GeometrySDD::fgkLay4Ndet           = 8;
 131 const Int_t    AliITSv11GeometrySDD::fgkLay4Nladd          = 22;
 132 const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH  = 7.5*fgkmm;
 133
 134 const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay3 = fgkLay3DetShortRadius;
 135 const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay4 = fgkLay4DetShortRadius;
 136 const Double_t AliITSv11GeometrySDD::fgkDistEndLaddCardsLadd = 0.*fgkmm;
 137
 138 //hybrid
 139 const Double_t AliITSv11GeometrySDD::fgkHybridAngle       = 46;           // approx !!!
 140 // Origine taken at the hybrid corner :
 141 const Double_t AliITSv11GeometrySDD::fgkHybridLength      = 65*fgkmm;
 142 const Double_t AliITSv11GeometrySDD::fgkHybridWidth       = 41*fgkmm;
 143 const Double_t AliITSv11GeometrySDD::fgkHybRndHoleRad     = 1.05*fgkmm;
 144 const Double_t AliITSv11GeometrySDD::fgkHybRndHoleZ       = 2.5*fgkmm;
 145 const Double_t AliITSv11GeometrySDD::fgkHybRndHoleX       = fgkHybridWidth-23.599*fgkmm;
 146
 147 const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleDZ    =   9.698*fgkmm;
 148 const Double_t AliITSv11GeometrySDD::fgkHybFLlowHolePasDX =  10.754*fgkmm;
 149 const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleAmbDX =   9.122*fgkmm;
 150   // center of ships to the border
 151 const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ4    = fgkHybridLength-(4.654      )*fgkmm-fgkHybFLlowHoleDZ/2;
 152 const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ3    = fgkHybridLength-(4.654+15.  )*fgkmm-fgkHybFLlowHoleDZ/2;
 153 const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ2    = fgkHybridLength-(4.654+15.*2)*fgkmm-fgkHybFLlowHoleDZ/2;
 154 const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ1    = fgkHybridLength-(4.654+15.*3)*fgkmm-fgkHybFLlowHoleDZ/2;
 155 const Double_t AliITSv11GeometrySDD::fgkHybFLlowPasX      = fgkHybridWidth-32.775*fgkmm;
 156 const Double_t AliITSv11GeometrySDD::fgkHybFLlowAmbX      = fgkHybridWidth-20.791*fgkmm;
 157 const Double_t AliITSv11GeometrySDD::fgkHybChipsDZ        =  9.221*fgkmm;
 158 const Double_t AliITSv11GeometrySDD::fgkHybPascalDX       = 10.245*fgkmm;
 159 const Double_t AliITSv11GeometrySDD::fgkHybAmbraDX        =  8.51*fgkmm;
 160 const Double_t AliITSv11GeometrySDD::fgkHybFLUpperWidth   = 15.012*fgkmm;
 161 const Double_t AliITSv11GeometrySDD::fgkHybFLUpperLength  = 59.878*fgkmm;
 162 const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAlDZ    = 11.183*fgkmm;
 163 const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAldx    =  2.307*fgkmm;
 164
 165 const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorLen   = 12.000*fgkmm;
 166 const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorWid   =  1.490*fgkcm; //???
 167 const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorAng   = 40.0;
 168
 169 const Double_t AliITSv11GeometrySDD::fgkmu = 1*fgkmicron; // 1*fgkmicron; // can be increase for checking thin objects
 170 const Double_t AliITSv11GeometrySDD::fgkHybridThBridgeThick =  0.25*fgkmm;               // ???
 171 const Double_t AliITSv11GeometrySDD::fgkHybAlThick         =  30*fgkmu;
 172 const Double_t AliITSv11GeometrySDD::fgkHybUpThick         =  20*fgkmu;
 173 const Double_t AliITSv11GeometrySDD::fgkHybGlueScrnThick   =  50*fgkmu;           // ??? ?????
 174 const Double_t AliITSv11GeometrySDD::fgkHybGlueLowThick    =  90*fgkmu;
 175 const Double_t AliITSv11GeometrySDD::fgkHybGlueUpThick     =  90*fgkmu;           // sur ?????
 176 const Double_t AliITSv11GeometrySDD::fgkHybAlCCThick       =  12*fgkmu;
 177 const Double_t AliITSv11GeometrySDD::fgkHybUpCCThick       =  12*fgkmu;
 178 const Double_t AliITSv11GeometrySDD::fgkHybChipThick       = 150*fgkmu;
 179 const Double_t AliITSv11GeometrySDD::fgkHybGlueAgThick     =  50*fgkmu;          // ??? ????
 180 const Double_t AliITSv11GeometrySDD::fgkHybUnderNiThick    =  20*fgkmu;          // ??? ????
 181 const Int_t    AliITSv11GeometrySDD::fgkNHybSMD = 25;
 182 const Double_t AliITSv11GeometrySDD::fgkHybSMDposX[fgkNHybSMD]     =
 183           {2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,21.40*fgkmm,
 184            2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
 185            2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,17.09*fgkmm,21.40*fgkmm,
 186            2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
 187            1.63*fgkmm,5.22*fgkmm,13.59*fgkmm,21.40*fgkmm};
 188 const Double_t AliITSv11GeometrySDD::fgkHybSMDposZ[fgkNHybSMD]     =
 189          { 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm,
 190            17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,
 191            32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,
 192            47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,
 193            62.68*fgkmm,62.06*fgkmm,62.06*fgkmm,62.06*fgkmm};
 194 const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleW      =   0.954*fgkmm;
 195 const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleL      =   0.47 *fgkmm;
 196 const Double_t AliITSv11GeometrySDD::fgkHybSMDendW         =   1.132*fgkmm;
 197 const Double_t AliITSv11GeometrySDD::fgkHybSMDendL         =   0.925*fgkmm;
 198 const Double_t AliITSv11GeometrySDD::fgkHybSMDheight       = 400.*fgkmu;          // ??? ????!!!!!!!
 199
 200 const Double_t AliITSv11GeometrySDD::fgkWaferThickness     = 300.*fgkmu;
 201 const Double_t AliITSv11GeometrySDD::fgkWaferWidth         =  72.5 *fgkmm;
 202 const Double_t AliITSv11GeometrySDD::fgkWaferLength        =  87.6 *fgkmm;
 203 const Double_t AliITSv11GeometrySDD::fgkWaferThickSens     = 299.8*fgkmu;
 204 const Double_t AliITSv11GeometrySDD::fgkWaferWidthSens     =  70.17*fgkmm;
 205 // 256 anodes times 294 microns of pitch
 206 const Double_t AliITSv11GeometrySDD::fgkWaferLengthSens    =  256*294*fgkmicron;
 207
 208 const Double_t AliITSv11GeometrySDD::fgkDigitCablWidth     = 18.4*fgkmm;
 209 const Double_t AliITSv11GeometrySDD::fgkDigitCablAlThick   = (30+30*8./10.)*fgkmicron; // will probably change
 210 const Double_t AliITSv11GeometrySDD::fgkDigitCablPolyThick = (20+12)*fgkmicron;        // will probably change
 211
 212 const Double_t AliITSv11GeometrySDD::fgkWaHVcableAlThick   = 30*2./10.*fgkmu;  // will probably change // Al ratio is random !!!
 213 const Double_t AliITSv11GeometrySDD::fgkWaHVcablePolyThick = 175*fgkmu;        // will probably change
 214 const Double_t AliITSv11GeometrySDD::fgkWaHVcableLength    = 67.08*fgkmm;
 215 const Double_t AliITSv11GeometrySDD::fgkWaHVcableWitdh     = 17.4*fgkmm;              //  check !!!
 216 const Double_t AliITSv11GeometrySDD::fgkWaHVcableDW        = 5.24*fgkmm; //5.24*fgkmm;//  check !!!
 217
 218 const Double_t AliITSv11GeometrySDD::fgkSensorGlassLX      =   5.  *fgkmm;
 219 const Double_t AliITSv11GeometrySDD::fgkSensorGlassLZ      =   5.  *fgkmm;
 220 const Double_t AliITSv11GeometrySDD::fgkSensorGlassLY      = 150.  *fgkmu;
 221 const Double_t AliITSv11GeometrySDD::fgkGlassDXOnSensor    =  26.28*fgkmm;             //  check !!!
 222 const Double_t AliITSv11GeometrySDD::fgkGlassDZOnSensor    =  22.50*fgkmm;             //  check !!!
 223
 224 const Double_t AliITSv11GeometrySDD::fgkTransitHVAlThick    = 30*2./10.*fgkmu; //  check // will probably change //Al ratio is random
 225 const Double_t AliITSv11GeometrySDD::fgkTransitHVPolyThick  = 100*fgkmu;       //  check  // will probably change
 226 const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLX     =  71.46*fgkmm;           //  check !!!
 227 const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLZ     =  21.3*fgkmm;
 228 const Double_t AliITSv11GeometrySDD::fgkTransitHVBondingLZ  =   3.6*fgkmm;
 229 const Double_t AliITSv11GeometrySDD::fgkTransitHVtailLength =  27*fgkmm;              // ???, not yet fixed ...
 230 const Double_t AliITSv11GeometrySDD::fgkTransitHVtailWidth  =  26*fgkmm;
 231 const Double_t AliITSv11GeometrySDD::fgkTransitHVtailXpos   =   8*fgkmm;    //8*fgkmm          // ???, a mesurer !!!
 232 const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLZ     =  10.34*fgkmm;
 233 const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLeftZ  =   4.11*fgkmm;
 234 const Double_t AliITSv11GeometrySDD::fgkTransitHVsideRightZ =   3.5*fgkmm;           // ???, a mesurer !!!
 235
 236 const Double_t AliITSv11GeometrySDD::fgkLongHVcablePolyThick= (20+30+125+30+20+30+125+30+20)*fgkmu; //  check  // will probably change
 237 const Double_t AliITSv11GeometrySDD::fgkLongHVcableAlThick  = (30+30*2/10+30)*fgkmu;                //  check  // will probably change
 238 const Double_t AliITSv11GeometrySDD::fgkLongHVcableSeparation = 600*fgkmicron;
 239
 240 const Double_t AliITSv11GeometrySDD::fgkRubyDX              =  14.*fgkmm;
 241 const Double_t AliITSv11GeometrySDD::fgkRubyZladd3          = 250*fgkmm;
 242 const Double_t AliITSv11GeometrySDD::fgkRubyZladd4          = 325*fgkmm;
 243
 244 // the stesalite ladder foot at its end
 245 const Double_t AliITSv11GeometrySDD::fgkLadFootX         = 60.*fgkmm;
 246 const Double_t AliITSv11GeometrySDD::fgkLadFootZ         = 20.*fgkmm;
 247 const Double_t AliITSv11GeometrySDD::fgkLadFootY         =  8.*fgkmm;
 248 const Double_t AliITSv11GeometrySDD::fgkLadFootMiddleY    =  4.5*fgkmm;
 249 const Double_t AliITSv11GeometrySDD::fgkLadBox1X         = 23.*fgkmm;
 250 const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintX  =  6.*fgkmm;
 251 const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintY  =  1.*fgkmm;
 252 const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintBorder = 4.*fgkmm;
 253 const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleZ     =  8.*fgkmm;
 254 const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleX     =  9.*fgkmm;
 255 const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleY     =  6.5*fgkmm;
 256 const Double_t AliITSv11GeometrySDD::fgkRubyCageAxisShift =  0.5*fgkmm;
 257 const Double_t AliITSv11GeometrySDD::fgkScrewM4diam       =  4.*fgkmm;
 258
 259 const Double_t AliITSv11GeometrySDD::fgkRubyScrewShiftToCenterY = 0.1;
 260 const Double_t AliITSv11GeometrySDD::fgkRubyHoleDiam            = 0.5;
 261
 262 // the U cooling pipe and its heat exchanger in end-ladder cards system
 263 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay3 = 138*fgkmm;
 264 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay4 = 150*fgkmm;
 265 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUwidth      =  59*fgkmm;
 266 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeRadius      =   5*fgkmm;
 267 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeInnerDiam   =   2.8*fgkmm;
 268 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeOuterDiam   =   3.*fgkmm;
 269 //--- The al body of the cooling syst.of the heat exchanger :
 270 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3    = 112.*fgkmm;   //
 271 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4    = 125.*fgkmm;   //
 272 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX        =   4.75*fgkmm; // the arms of the U cooling tube
 273 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY        =   6.8*fgkmm;
 274 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY    =   1.03*fgkmm; // shift in Y of the arms from the axis
 275 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX    =   0.125*fgkmm;// shift in X of the arms from the axis
 276 const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos     =   8.9*fgkmm;  //
 277
 278 // LV card :
 279 const Double_t AliITSv11GeometrySDD::fgkLVcardX     = 26.525*fgkmm;
 280 const Double_t AliITSv11GeometrySDD::fgkLVcardY     = 44.95*fgkmm;
 281 const Double_t AliITSv11GeometrySDD::fgkLVcardZ     = 1.*fgkmm; // all except Cu layer   //???
 282 const Double_t AliITSv11GeometrySDD::fgkLVcardCuZ   = 0.1*fgkmm;   //???
 283
 284 const Double_t AliITSv11GeometrySDD::fgkLVChip0X    = 16.525*fgkmm;
 285 const Double_t AliITSv11GeometrySDD::fgkLVChip0Y    = 10.8*fgkmm;
 286 const Double_t AliITSv11GeometrySDD::fgkLVChip0Z    =  3.5*fgkmm; // all except si layer   //???
 287 const Double_t AliITSv11GeometrySDD::fgkLVChip0SiZ  =  0.2*fgkmm; //???????????????????????????????????????????????????
 288 const Double_t AliITSv11GeometrySDD::fgkLVChip0PosX = 13.*fgkmm; //19.95*fgkmm;  ???
 289 const Double_t AliITSv11GeometrySDD::fgkLVChip0PosY = 10.3*fgkmm;
 290
 291 const Double_t AliITSv11GeometrySDD::fgkLVChip1X    = 6.00*fgkmm;
 292 const Double_t AliITSv11GeometrySDD::fgkLVChip1Y    = 6.00*fgkmm;
 293 const Double_t AliITSv11GeometrySDD::fgkLVChip1Z    = 1*fgkmm;  // ???
 294 const Double_t AliITSv11GeometrySDD::fgkLVChip1SiZ  = 0.2*fgkmm;  // ???
 295 const Double_t AliITSv11GeometrySDD::fgkLVChip1PosX = 18.*fgkmm;
 296 const Double_t AliITSv11GeometrySDD::fgkLVChip1PosY = 27.6*fgkmm;
 297
 298 const Double_t AliITSv11GeometrySDD::fgkLVChip2X    = 6.00*fgkmm;
 299 const Double_t AliITSv11GeometrySDD::fgkLVChip2Y    = 6.00*fgkmm;
 300 const Double_t AliITSv11GeometrySDD::fgkLVChip2Z    = 1*fgkmm;    // ???
 301 const Double_t AliITSv11GeometrySDD::fgkLVChip2SiZ  = 0.2*fgkmm;  //???
 302 const Double_t AliITSv11GeometrySDD::fgkLVChip2PosX = 18.0*fgkmm;
 303 const Double_t AliITSv11GeometrySDD::fgkLVChip2PosY = 39.0*fgkmm;
 304
 305 const Double_t AliITSv11GeometrySDD::fgkLVChip3X    = 4.01*fgkmm;
 306 const Double_t AliITSv11GeometrySDD::fgkLVChip3Y    = 4.01*fgkmm;
 307 const Double_t AliITSv11GeometrySDD::fgkLVChip3Z    = 1*fgkmm; // ???
 308 const Double_t AliITSv11GeometrySDD::fgkLVChip3SiZ  = 0.2*fgkmm;
 309 const Double_t AliITSv11GeometrySDD::fgkLVChip3PosX = 20.7*fgkmm;
 310 const Double_t AliITSv11GeometrySDD::fgkLVChip3PosY = 21.4*fgkmm;
 311
 312 const Double_t AliITSv11GeometrySDD::fgkLVcoolX1    = 17.25*fgkmm;
 313 const Double_t AliITSv11GeometrySDD::fgkLVcoolY1    =  8.7*fgkmm;
 314 const Double_t AliITSv11GeometrySDD::fgkLVcoolZ1    =  1.*fgkmm;
 315
 316 const Double_t AliITSv11GeometrySDD::fgkLVcoolX2    =  3.5*fgkmm;
 317 const Double_t AliITSv11GeometrySDD::fgkLVcoolY2    =  8.7*fgkmm;
 318 const Double_t AliITSv11GeometrySDD::fgkLVcoolZ2    =  2.3*fgkmm;
 319
 320 const Double_t AliITSv11GeometrySDD::fgkLVcoolX3    =  4.75*fgkmm;
 321 const Double_t AliITSv11GeometrySDD::fgkLVcoolY3    =  3.1*fgkmm; //+0.1=glue
 322 const Double_t AliITSv11GeometrySDD::fgkLVcoolPosY  = 6.5*fgkmm;
 323
 324 // HV card :
 325 const Double_t AliITSv11GeometrySDD::fgkHVCardCeramX    = 54.01*fgkmm;
 326 const Double_t AliITSv11GeometrySDD::fgkHVCardCeramY    = 40.89*fgkmm;
 327 const Double_t AliITSv11GeometrySDD::fgkHVCardCeramZ    =  0.7*fgkmm;  // ???
 328
 329 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1X    =   6.8*fgkmm;
 330 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Z    =   1.*fgkmm;  // ???
 331 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Ymid =   4.1*fgkmm;
 332 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Yend =   0.95*fgkmm; // doesn't take into account the soldering
 333 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosX =  13.1*fgkmm;
 334 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosY =  14.5*fgkmm;
 335
 336 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2X    =   6.8*fgkmm;
 337 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Z    =   1.*fgkmm;  // ???
 338 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Ymid =   2.9*fgkmm;
 339 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Yend =   0.95*fgkmm;
 340 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosX = -12.6*fgkmm;
 341 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosY =  16.54*fgkmm;
 342
 343 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xmid =   3.0*fgkmm;
 344 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xend =   0.91*fgkmm;
 345 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Z    =   2.*fgkmm;      // ???
 346 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Y    =   3.43*fgkmm;
 347
 348 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX1 =  14.6*fgkmm;
 349 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX2 =   7.2*fgkmm;
 350 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX3 =   2.52*fgkmm;
 351 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX4 =  -4.96*fgkmm;
 352 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX5 = -13.82*fgkmm;
 353 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY1 =   6.27*fgkmm;
 354 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY2 =   0.7*fgkmm;
 355 const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY3 =   9.1*fgkmm;
 356
 357 const Double_t AliITSv11GeometrySDD::fgkHVCardCool1X     =  14.*fgkmm;
 358 const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Y     =   9.5*fgkmm;
 359 const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Z     =   2.*fgkmm;
 360 const Double_t AliITSv11GeometrySDD::fgkHVCardCool2X     =  14.25*fgkmm;
 361 const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Y     =   3.5*fgkmm;
 362 const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Z     =   4.5*fgkmm;
 363 const Double_t AliITSv11GeometrySDD::fgkHVCardCool3X     =   4.5*fgkmm;
 364 const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Y     =   3.5*fgkmm;
 365 const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Z     =   7.2*fgkmm;
 366 const Double_t AliITSv11GeometrySDD::fgkHVCardCoolDY     =   6.*fgkmm;
 367
 368 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX1     = 19.5*fgkmm;
 369 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY1     =  2*fgkmm;
 370 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX2     = 35.*fgkmm;
 371 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY2     =  3.9*fgkmm;
 372 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ      = 17.*fgkmm;
 373 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppAngle  = 45;
 374 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX3     =  4.5*fgkmm;
 375 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY3     =  3.*fgkmm;
 376 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ3     = 12.*fgkmm;
 377 const Double_t AliITSv11GeometrySDD::fgkCarlosSuppTopLen = 8.65*fgkmm;
 378
 379 // screws fixing boards to the end-ladder on the U tube
 380 const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadR   = 1.85*fgkmm;
 381 const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadH   = 1.5*fgkmm;
 382 const Double_t AliITSv11GeometrySDD::fgkLittleScrewR       = 0.7*fgkmm;
 383 const Double_t AliITSv11GeometrySDD::fgkShiftLittleScrewLV = 3*fgkmm;     // ???
 384 const Double_t AliITSv11GeometrySDD::fgkLittleLVScrewHeadR = 1.2*fgkmm;   // ???
 385
 386 // CARLOS board
 387 const Double_t AliITSv11GeometrySDD::fgkCarlosCardX1          = (25.50+28.50)*fgkmm; // length (first part of Carlos card)
 388 const Double_t AliITSv11GeometrySDD::fgkCarlosCardY1          =    1.6*fgkmm;        // thickness
 389 const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ1          =   40.8*fgkmm;        // width
 390 const Double_t AliITSv11GeometrySDD::fgkCarlosCardCuY         =    0.1*fgkmm;   // thickness of Cu layer (strips)
 391 const Double_t AliITSv11GeometrySDD::fgkCarlosCardX2          =   25.50*fgkmm;  // length (2nd part of Carlos card)
 392 const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ2          =    8.20*fgkmm;  // width
 393
 394 const Double_t AliITSv11GeometrySDD::fgkCarlosCardChipSiThick =   0.1*fgkmm;  // ??? idem for all chips ???
 395 const Double_t AliITSv11GeometrySDD::fgkCarlosCardShift       =   9*fgkmm;   // ??? shift in z w.r.t. heat bridge
 396
 397 // size and position of various chips on carlos end-ladder board
 398 const Double_t AliITSv11GeometrySDD::fgkCarlosU1X             =  13*fgkmm;
 399 const Double_t AliITSv11GeometrySDD::fgkCarlosU1Y             =   1.68*fgkmm;
 400 const Double_t AliITSv11GeometrySDD::fgkCarlosU1Z             =  13*fgkmm;
 401 const Double_t AliITSv11GeometrySDD::fgkCarlosU1posX          =  18.4*fgkmm;
 402 const Double_t AliITSv11GeometrySDD::fgkCarlosU1posZ          =  -7.2*fgkmm;
 403
 404 const Double_t AliITSv11GeometrySDD::fgkCarlosU2X             =  13.75*fgkmm;
 405 const Double_t AliITSv11GeometrySDD::fgkCarlosU2Y             =   1.60*fgkmm;
 406 const Double_t AliITSv11GeometrySDD::fgkCarlosU2Z             =  13.85*fgkmm;
 407 const Double_t AliITSv11GeometrySDD::fgkCarlosU2posX          =  -0.375*fgkmm;
 408 const Double_t AliITSv11GeometrySDD::fgkCarlosU2posZ          =  -9.725*fgkmm;
 409
 410 const Double_t AliITSv11GeometrySDD::fgkCarlosU3X             =   5*fgkmm;
 411 const Double_t AliITSv11GeometrySDD::fgkCarlosU3Y             =   1.*fgkmm;
 412 const Double_t AliITSv11GeometrySDD::fgkCarlosU3Z             =   5*fgkmm;
 413 const Double_t AliITSv11GeometrySDD::fgkCarlosU3posX          =   6.4*fgkmm;
 414 const Double_t AliITSv11GeometrySDD::fgkCarlosU3posZ          =   9.9*fgkmm;
 415
 416 // U4 like U3
 417 const Double_t AliITSv11GeometrySDD::fgkCarlosU4posX          = -12*fgkmm;
 418 const Double_t AliITSv11GeometrySDD::fgkCarlosU4posZ          =   3.6*fgkmm;
 419
 420 const Double_t AliITSv11GeometrySDD::fgkCarlosU17X            =  16*fgkmm;
 421 const Double_t AliITSv11GeometrySDD::fgkCarlosU17Y            =   3.5*fgkmm;
 422 const Double_t AliITSv11GeometrySDD::fgkCarlosU17Z            =  10.9*fgkmm;
 423 const Double_t AliITSv11GeometrySDD::fgkCarlosU17posX         = -17.84*fgkmm;
 424 const Double_t AliITSv11GeometrySDD::fgkCarlosU17posZ         = -10.95*fgkmm;
 425
 426 const Double_t AliITSv11GeometrySDD::fgkCarlosU35X            =   4*fgkmm;
 427 const Double_t AliITSv11GeometrySDD::fgkCarlosU35Y            =   1.*fgkmm;
 428 const Double_t AliITSv11GeometrySDD::fgkCarlosU35Z            =   4*fgkmm;
 429 const Double_t AliITSv11GeometrySDD::fgkCarlosU35posX         = -21.6*fgkmm;
 430 const Double_t AliITSv11GeometrySDD::fgkCarlosU35posZ         =   2.3*fgkmm;
 431
 432 const Double_t AliITSv11GeometrySDD::fgkCarlosU36X            =   6*fgkmm;
 433 const Double_t AliITSv11GeometrySDD::fgkCarlosU36Y            =   1.*fgkmm;
 434 const Double_t AliITSv11GeometrySDD::fgkCarlosU36Z            =   6*fgkmm;
 435 const Double_t AliITSv11GeometrySDD::fgkCarlosU36posX         = -21.6*fgkmm;
 436 const Double_t AliITSv11GeometrySDD::fgkCarlosU36posZ         =   9.6*fgkmm;
 437
 438 const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1X            =   8*fgkmm;
 439 const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Y            =   1.7*fgkmm; // look thicker than design number (0.7) ! ???
 440 const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Z            =   3.7*fgkmm;
 441 const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posX         = -12*fgkmm;
 442 const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posZ         =  10.6*fgkmm;
 443
 444 // distance from the heat bridge center to the card center :
 445 const Double_t AliITSv11GeometrySDD::fgkCarlosCard2HeatBridge = fgkCarlosSuppY2/2+fgkCarlosCardY1/2+fgkCarlosU1Y+0.1*fgkmm;
 446
 447 // some pieces at the end of the carbon fiber ladder
 448  const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay3Len   = 467.*fgkmm;  // ???
 449  const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay4Len   = 616.*fgkmm;  // ???
 450  const Double_t AliITSv11GeometrySDD::fgkHVguideX1         =  42.5*fgkmm;
 451  const Double_t AliITSv11GeometrySDD::fgkHVguideY1         =   7.*fgkmm;
 452  const Double_t AliITSv11GeometrySDD::fgkHVguideZ1         =  10.*fgkmm;
 453  const Double_t AliITSv11GeometrySDD::fgkHVguideZ2         =   6.*fgkmm;
 454  const Double_t AliITSv11GeometrySDD::fgkHVguideDX         =  -8.5*fgkmm;
 455  const Double_t AliITSv11GeometrySDD::fgkHVguideSuppFullZ  = 37.5*fgkmm;
 456
 457 // Cooling connector between phynox and plastic cooling water tubes
 458 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeRmin = 1 *fgkmm;
 459 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR1   = 2.5*fgkmm; // ???
 460 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL1   = 3.*fgkmm;  // ???
 461 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR2   = 3.5*fgkmm;  // ???
 462 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL2   = 2.*fgkmm;  // ???
 463 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR3   = 3.*fgkmm;  // ???
 464 const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL3   = 5 *fgkmm;  // ???
 465
 466
 467 // parameters for coding SDD cables on SDD and SSD cones
 468 const Double_t AliITSv11GeometrySDD::fgkSectionCuPerMod = 3*2*0.006 + 3*2*0.0005 + 2*0.002;
 469 //                                             copper :     LV     +  signal  +  HV(HV ???)
 470 const Double_t AliITSv11GeometrySDD::fgkSectionPlastPerMod = (TMath::Pi()*(3*0.36*0.36/4 + 3*0.21*0.21/4 + 2*0.115*0.115/4)
 471                                                               - fgkSectionCuPerMod);
 472
 473 const Double_t AliITSv11GeometrySDD::fgkSectionGlassPerMod = 3*0.006; // ???
 474 const Double_t AliITSv11GeometrySDD::fgkSectionCoolPolyuEL = 0.4672;
 475 const Double_t AliITSv11GeometrySDD::fgkSectionCoolWaterEL = 0.3496;
 476 const Double_t AliITSv11GeometrySDD::fgkEndLadderEarthCableR = 0.5*fgkmm;
 477 // (sections are given in cm square)
 478 const Double_t AliITSv11GeometrySDD::fgkCableBendRatio = 1.3; // ??? this factor account for the bending of cables
 479 const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilThick = 0.1*fgkmm; // Thickness of Al foil on hybrid side - TO BE CHECKED
 480 const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilWide = 4.2*fgkmm; // Width of Al foil on hybrid side - from digitCableA
 481 const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilSide = 2.0*fgkmm; // Side length of Al foil on hybrid side
 482
 483 const Double_t AliITSv11GeometrySDD::fgkConeSDDr1 = 11.87574*fgkcm;
 484 const Double_t AliITSv11GeometrySDD::fgkConeSDDr2 = 26.07574*fgkcm;
 485 const Double_t AliITSv11GeometrySDD::fgkConeSDDz1 =  3.36066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
 486 const Double_t AliITSv11GeometrySDD::fgkConeSDDz2 = 17.56066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
 487 // These last parameters come from cone's code and define the slope
 488 // and position of the SDD cone end.  For some unknown reason, this doesn't
 489 // allow to stick on the SDD cone. This has to be checked when a correct
 490 // version of the cone is available ... For now 'm applying some approximative
 491 // corrections
 492
 493 const Double_t AliITSv11GeometrySDD::fgkSDDCableR1    = 16*fgkcm; // ??? // part 1 of "cable cone"
 494 const Double_t AliITSv11GeometrySDD::fgkSDDCableR2    = 23*fgkcm; // ??? // part 1/2 of "cable cone"
 495 const Double_t AliITSv11GeometrySDD::fgkSDDCableR3    = 26*fgkcm; // ??? // part 2 of "cable cone"
 496
 497 const Double_t AliITSv11GeometrySDD::fgkSDDCableDZint =  3.5*fgkcm;
 498 const Double_t AliITSv11GeometrySDD::fgkSDDCableR5    =  37*fgkcm; // third part of "cable cone"
 499 const Double_t AliITSv11GeometrySDD::fgkSDDCableZ5    =  65*fgkcm; // third part of "cable cone"
 500
 501
 502
 503
 504
 505
 506
 507 ClassImp(AliITSv11GeometrySDD)
 508
 509 //________________________________________________________________________
 510 AliITSv11GeometrySDD::AliITSv11GeometrySDD():
 511   AliITSv11Geometry(),
 512   fPinSupport(0),
 513   fCoolPipeSupportL(0),
 514   fCoolPipeSupportR(0),
 515   fSDDsensor3(0),
 516   fSDDsensor4(0),
 517   fBaseThermalBridge(0),
 518   fHybrid(0),
 519   fLadderFoot(0),
 520   fCardLVR(0),
 521   fCardLVL(0),
 522   fCardHV(0),
 523   fCardCarlos(0),
 524   fRaccordoL(0),
 525   fDigitCableLay3A(0),
 526   fDigitCableLay3B(0),
 527   fDigitCableLay4A(0),
 528   fDigitCableLay4B(0),
 529   fMotherVol(0),
 530   fAddHybrids(kTRUE),
 531   fAddSensors(kTRUE),
 532   fAddHVcables(kTRUE),
 533   fAddCables(kTRUE),
 534   fAddCoolingSyst(kTRUE),
 535   fCoolingOn(kTRUE),
 536   fAddOnlyLadder3min(-1),
 537   fAddOnlyLadder3max(-1),
 538   fAddOnlyLadder4min(-1),
 539   fAddOnlyLadder4max(-1),
 540   fColorCarbonFiber(4),
 541   fColorRyton(5),
 542   fColorPhynox(7),
 543   fColorSilicon(3),
 544   fColorAl(7),
 545   fColorPolyhamide(5),
 546   fColorGlass(2),
 547   fColorSMD(12),
 548   fColorSMDweld(17),
 549   fColorStesalite(20),
 550   fLay3LadderUnderSegDH(0),
 551   fLay4LadderUnderSegDH(0),
 552   fLay3LaddShortRadius(0),
 553   fLay3LaddLongRadius(0),
 554   fLay4LaddShortRadius(0),
 555   fLay4LaddLongRadius(0)
 556 {
 557   //
 558   // Standard constructor
 559   //
 560   fCommonVol[0] = NULL;
 561   fCommonVol[1] = NULL;
 562   fCommonTr[0] = NULL;
 563   fCommonTr[1] = NULL;
 564   for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
 565     fLaddSegCommonVol[i] = NULL;
 566     fLaddSegCommonTr[i] = NULL;
 567   }
 568   SetParameters();
 569 }
 570
 571
 572 //________________________________________________________________________
 573 AliITSv11GeometrySDD::AliITSv11GeometrySDD(Int_t debug) :
 574   AliITSv11Geometry(debug),
 575   fPinSupport(0),
 576   fCoolPipeSupportL(0),
 577   fCoolPipeSupportR(0),
 578   fSDDsensor3(0),
 579   fSDDsensor4(0),
 580   fBaseThermalBridge(0),
 581   fHybrid(0),
 582   fLadderFoot(0),
 583   fCardLVR(0),
 584   fCardLVL(0),
 585   fCardHV(0),
 586   fCardCarlos(0),
 587   fRaccordoL(0),
 588   fDigitCableLay3A(0),
 589   fDigitCableLay3B(0),
 590   fDigitCableLay4A(0),
 591   fDigitCableLay4B(0),
 592   fMotherVol(0),
 593   fAddHybrids(kTRUE),
 594   fAddSensors(kTRUE),
 595   fAddHVcables(kTRUE),
 596   fAddCables(kTRUE),
 597   fAddCoolingSyst(kTRUE),
 598   fCoolingOn(kTRUE),
 599   fAddOnlyLadder3min(-1),
 600   fAddOnlyLadder3max(-1),
 601   fAddOnlyLadder4min(-1),
 602   fAddOnlyLadder4max(-1),
 603   fColorCarbonFiber(4),
 604   fColorRyton(5),
 605   fColorPhynox(7),
 606   fColorSilicon(3),
 607   fColorAl(7),
 608   fColorPolyhamide(5),
 609   fColorGlass(2),
 610   fColorSMD(12),
 611   fColorSMDweld(17),
 612   fColorStesalite(20),
 613   fLay3LadderUnderSegDH(0),
 614   fLay4LadderUnderSegDH(0),
 615   fLay3LaddShortRadius(0),
 616   fLay3LaddLongRadius(0),
 617   fLay4LaddShortRadius(0),
 618   fLay4LaddLongRadius(0)
 619 {
 620   //
 621   // Constructor setting debugging level
 622   //
 623   fCommonVol[0] = NULL;
 624   fCommonVol[1] = NULL;
 625   fCommonTr[0] = NULL;
 626   fCommonTr[1] = NULL;
 627   for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
 628     fLaddSegCommonVol[i] = NULL;
 629     fLaddSegCommonTr[i] = NULL;
 630   }
 631   SetParameters();
 632 }
 633
 634 //________________________________________________________________________
 635 AliITSv11GeometrySDD::AliITSv11GeometrySDD(const AliITSv11GeometrySDD &s) :
 636   AliITSv11Geometry(s.GetDebug()),
 637   fPinSupport(s.fPinSupport),
 638   fCoolPipeSupportL(s.fCoolPipeSupportL),
 639   fCoolPipeSupportR(s.fCoolPipeSupportR),
 640   fSDDsensor3(s.fSDDsensor3),
 641   fSDDsensor4(s.fSDDsensor4),
 642   fBaseThermalBridge(s.fBaseThermalBridge),
 643   fHybrid(s.fHybrid),
 644   fLadderFoot(s.fLadderFoot),
 645   fCardLVR(s.fCardLVR),
 646   fCardLVL(s.fCardLVL),
 647   fCardHV(s.fCardHV),
 648   fCardCarlos(s.fCardCarlos),
 649   fRaccordoL(s.fRaccordoL),
 650   fDigitCableLay3A(s.fDigitCableLay3A),
 651   fDigitCableLay3B(s.fDigitCableLay3B),
 652   fDigitCableLay4A(s.fDigitCableLay4A),
 653   fDigitCableLay4B(s.fDigitCableLay4B),
 654   fMotherVol(s.fMotherVol),
 655   fAddHybrids(s.fAddHybrids),
 656   fAddSensors(s.fAddSensors),
 657   fAddHVcables(s.fAddHVcables),
 658   fAddCables(s.fAddCables),
 659   fAddCoolingSyst(s.fAddCoolingSyst),
 660   fCoolingOn(s.fCoolingOn),
 661   fAddOnlyLadder3min(s.fAddOnlyLadder3min),
 662   fAddOnlyLadder3max(s.fAddOnlyLadder3max),
 663   fAddOnlyLadder4min(s.fAddOnlyLadder4min),
 664   fAddOnlyLadder4max(s.fAddOnlyLadder4max),
 665   fColorCarbonFiber(s.fColorCarbonFiber),
 666   fColorRyton(s.fColorRyton),
 667   fColorPhynox(s.fColorPhynox),
 668   fColorSilicon(s.fColorSilicon),
 669   fColorAl(s.fColorAl),
 670   fColorPolyhamide(s.fColorPolyhamide),
 671   fColorGlass(s.fColorGlass),
 672   fColorSMD(s.fColorSMD),
 673   fColorSMDweld(s.fColorSMDweld),
 674   fColorStesalite(s.fColorStesalite),
 675   fLay3LadderUnderSegDH(s.fLay3LadderUnderSegDH),
 676   fLay4LadderUnderSegDH(s.fLay4LadderUnderSegDH),
 677   fLay3LaddShortRadius(s.fLay3LaddShortRadius),
 678   fLay3LaddLongRadius(s.fLay3LaddLongRadius),
 679   fLay4LaddShortRadius(s.fLay4LaddShortRadius),
 680   fLay4LaddLongRadius(s.fLay4LaddLongRadius)
 681 {
 682   //     Copy Constructor
 683   // do only a "shallow copy" ...
 684   fCommonVol[0] = s.fCommonVol[0];
 685   fCommonVol[1] = s.fCommonVol[1];
 686   fCommonTr[0] = s.fCommonTr[0];
 687   fCommonTr[1] = s.fCommonTr[1];
 688   for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
 689     fLaddSegCommonVol[i] = s.fLaddSegCommonVol[i];
 690     fLaddSegCommonTr[i] = s.fLaddSegCommonTr[i];
 691   }
 692   SetParameters();
 693 }
 694
 695 //________________________________________________________________________
 696 AliITSv11GeometrySDD& AliITSv11GeometrySDD::
 697 operator=(const AliITSv11GeometrySDD &s) {
 698   //     Assignment operator
 699   if(&s == this) return *this;
 700   fMotherVol = s.fMotherVol;
 701   fAddHybrids = s.fAddHybrids;
 702   fAddSensors = s.fAddSensors;
 703   fAddHVcables = s.fAddHVcables;
 704   fAddCables = s.fAddCables;
 705   fAddCoolingSyst = s.fAddCoolingSyst;
 706   fCoolingOn = s.fCoolingOn;
 707   fAddOnlyLadder3min = s.fAddOnlyLadder3min;
 708   fAddOnlyLadder3max = s.fAddOnlyLadder3max;
 709   fAddOnlyLadder4min = s.fAddOnlyLadder4min;
 710   fAddOnlyLadder4max = s.fAddOnlyLadder4max;
 711   return *this;
 712 }
 713
 714 //________________________________________________________________________
 715 AliITSv11GeometrySDD::~AliITSv11GeometrySDD() {
 716   // Look like a destructor
 717   // Smell like a destructor
 718   // And actually is the destructor
 719   if (fDigitCableLay3A) delete [] fDigitCableLay3A;
 720   if (fDigitCableLay3B) delete [] fDigitCableLay3B;
 721   if (fDigitCableLay4A) delete [] fDigitCableLay4A;
 722   if (fDigitCableLay4B) delete [] fDigitCableLay4B;
 723 }
 724
 725 //________________________________________________________________________
 726 void AliITSv11GeometrySDD::SetParameters() {
 727   //
 728   // Define display colors and the non constant geometry parameters
 729   //
 730
 731   Double_t detLadderDist = 8*fgkmm;
 732
 733   fLay3LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
 734   fLay4LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
 735
 736   // radius from the center to the CF ladder :
 737   fLay3LaddShortRadius = (fgkLay3DetShortRadius
 738                           + fgkLadWaferSep+2*fgkWaferThickness
 739                           + detLadderDist);
 740   fLay3LaddLongRadius  = (fgkLay3DetLongRadius
 741                           + fgkLadWaferSep+2*fgkWaferThickness
 742                           + detLadderDist);
 743   fLay4LaddShortRadius = (fgkLay4DetShortRadius
 744                           + fgkLadWaferSep+2*fgkWaferThickness
 745                           + detLadderDist);
 746   fLay4LaddLongRadius  = (fgkLay4DetLongRadius
 747                           + fgkLadWaferSep+2*fgkWaferThickness
 748                           + detLadderDist);
 749
 750   fLay3sensorZPos[0]= (  35.8+72.4+75.8 )*fgkmm;
 751   fLay3sensorZPos[1]= (  35.8+72.4      )*fgkmm;
 752   fLay3sensorZPos[2]= (  35.8           )*fgkmm;
 753   fLay3sensorZPos[3]= ( -37.9           )*fgkmm;
 754   fLay3sensorZPos[4]= ( -37.9-74.9      )*fgkmm;
 755   fLay3sensorZPos[5]= ( -37.9-74.9-71.1 )*fgkmm;
 756
 757   fLay4sensorZPos[0] = (  38.5+73.2+75.4+71.6 )*fgkmm;
 758   fLay4sensorZPos[1] = (  38.5+73.2+75.4      )*fgkmm;
 759   fLay4sensorZPos[2] = (  38.5+73.2           )*fgkmm;
 760   fLay4sensorZPos[3] = (  38.5                )*fgkmm;
 761   fLay4sensorZPos[4] = ( -35.6                )*fgkmm;
 762   fLay4sensorZPos[5] = ( -35.6-74.8           )*fgkmm;
 763   fLay4sensorZPos[6] = ( -35.6-74.8-72.4      )*fgkmm;
 764   fLay4sensorZPos[7] = ( -35.6-74.8-72.4-76.  )*fgkmm;
 765 }
 766
 767
 768 //________________________________________________________________________
 769 TGeoMedium* AliITSv11GeometrySDD::GetMedium(const char* mediumName) {
 770   //
 771   // Called to get a medium, checks that it exists.
 772   // If not, prints an error and returns 0
 773   //
 774
 775   char ch[30];
 776   snprintf(ch, 30, "ITS_%s",mediumName);
 777   TGeoMedium* medium =  gGeoManager->GetMedium(ch);
 778   if (! medium)
 779     printf("Error(AliITSv11GeometrySDD)::medium %s not found !\n", mediumName);
 780   return medium;
 781 }
 782
 783
 784 //________________________________________________________________________
 785 Int_t AliITSv11GeometrySDD::GetLay3NLadders() const{
 786   // Get the actual number of ladder in layer 3
 787   if ( (fAddOnlyLadder3min<0) ||
 788        (fAddOnlyLadder3min >= fgkLay3Nladd) ||
 789        (fAddOnlyLadder3max<0) ||
 790        (fAddOnlyLadder3max >= fgkLay3Nladd) )
 791     return fgkLay3Nladd;
 792   else return (fAddOnlyLadder3max-fAddOnlyLadder3min+1);
 793 }
 794
 795
 796 //________________________________________________________________________
 797 Int_t AliITSv11GeometrySDD::GetLay4NLadders() const{
 798   // Get the actual number of ladder in layer 4
 799   if ( (fAddOnlyLadder4min<0) ||
 800        (fAddOnlyLadder4min >= fgkLay4Nladd) ||
 801        (fAddOnlyLadder4max<0) ||
 802        (fAddOnlyLadder4max >= fgkLay4Nladd) )
 803     return fgkLay4Nladd;
 804   else return (fAddOnlyLadder4max-fAddOnlyLadder4min+1);
 805 }
 806
 807
 808 //________________________________________________________________________
 809 void AliITSv11GeometrySDD::CreateBasicObjects() {
 810   //
 811   // Create basics objets which will be assembled together
 812   // in Layer3 and Layer4 functions
 813   //
 814
 815
 816   fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
 817   fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
 818   fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
 819   fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
 820
 821   fPinSupport = CreatePinSupport();
 822   fCoolPipeSupportL = CreateCoolPipeSupportL();
 823   fCoolPipeSupportR = CreateCoolPipeSupportR();
 824   CreateSDDsensor();
 825   fBaseThermalBridge = CreateBaseThermalBridge();
 826   fHybrid = CreateHybrid(0);
 827
 828   TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); //ITSsddCarbonM55J
 829   TGeoMedium *polyhamideSDD   = GetMedium("SDDKAPTON (POLYCH2)$");//ITSsddKAPTON_POLYCH2
 830   TGeoMedium *alSDD           = GetMedium("AL$"); //ITSal
 831   TGeoMedium *stainless       = GetMedium("AISI304L$"); // for screws
 832   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
 833   TGeoMedium *raccordMedium   = GetMedium("INOX$");  // same as AISI 316-L
 834
 835   //********************************************************************
 836   // pieces of the carbon fiber structure
 837   //********************************************************************
 838   Double_t dy             = fgkLadderSegBoxDH/2;
 839   Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
 840   Double_t halfTheta      = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
 841   Double_t alpha          = TMath::Pi()*3./4. - halfTheta/2.;
 842   Double_t beta           = (TMath::Pi() - 2.*halfTheta)/4.;
 843   Double_t dYTranslation  = (fgkLadderHeight/2.
 844                              -0.5*fgkLadderWidth*TMath::Tan(beta)
 845                              -fgkLadderBeamRadius);
 846   Double_t distCenterSideDown =  0.5*fgkLadderWidth/TMath::Cos(beta);
 847
 848   //--- the top V of the Carbon Fiber Ladder (segment)
 849   TGeoArb8 *cfLaddTop1 = CreateLadderSide( "CFladdTopCornerVol1shape",
 850                                            fgkSegmentLength/2., halfTheta,
 851                           -1, fgkLadderLa, fgkLadderHa, fgkLadderl);
 852   TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1",
 853                                   cfLaddTop1,carbonFiberLadderStruct);
 854   TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerVol2shape",
 855                                            fgkSegmentLength/2., halfTheta,
 856                            1, fgkLadderLa, fgkLadderHa, fgkLadderl);
 857   TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerVol2",
 858                                   cfLaddTop2, carbonFiberLadderStruct);
 859   cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
 860   cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
 861   TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2-dy, 0);
 862
 863   //--- the 2 side V
 864   TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerVol1shape",
 865                                             fgkSegmentLength/2., beta, -1,
 866                                             fgkLadderLb, fgkLadderHb, fgkLadderl);
 867   TGeoVolume *cfLaddSideVol1 = new TGeoVolume( "ITSsddCFladdSideCornerVol1",
 868                                    cfLaddSide1,carbonFiberLadderStruct);
 869   TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerVol2shape",
 870                                             fgkSegmentLength/2., beta, 1,
 871                                             fgkLadderLb, fgkLadderHb, fgkLadderl);
 872   TGeoVolume *cfLaddSideVol2 = new TGeoVolume( "ITSsddCFladdSideCornerVol2",
 873                                    cfLaddSide2,carbonFiberLadderStruct);
 874   cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
 875   cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
 876   TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
 877                                              alpha*TMath::RadToDeg());
 878   AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation-dy, 0);
 879   TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown,0,
 880                                              -alpha*TMath::RadToDeg());
 881   AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation-dy, 0);
 882
 883   //--- The beams
 884   // Beams on the sides
 885   Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
 886            TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
 887   //cout<<"Phi prime = "<<beamPhiPrime*TMath::RadToDeg()<<endl;
 888   Double_t beamLength = TMath::Sqrt( fgkLadderHeight*fgkLadderHeight/
 889                         ( TMath::Sin(beamPhiPrime)*TMath::Sin(beamPhiPrime))
 890                         + fgkLadderWidth*fgkLadderWidth/4.)-fgkLadderLa/2-fgkLadderLb/2;
 891   TGeoTubeSeg *sideBeamS = new TGeoTubeSeg(0, fgkLadderBeamRadius,beamLength/2.,
 892                                            0, 180);
 893   TGeoVolume *sideBeam = new TGeoVolume("ITSsddCFSideBeamVol", sideBeamS,
 894                              carbonFiberLadderStruct);
 895   sideBeam->SetLineColor(fColorCarbonFiber);
 896
 897   //Euler rotation : about Z, then new X, then new Z
 898   TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
 899                                             -beamPhiPrime*TMath::RadToDeg(),-90);
 900   TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
 901                                             beamPhiPrime*TMath::RadToDeg(), -90);
 902   TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
 903                                             beamPhiPrime*TMath::RadToDeg(), -90);
 904   TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
 905                                             -beamPhiPrime*TMath::RadToDeg(),-90);
 906
 907   TGeoCombiTrans *beamTransf[8];
 908   beamTransf[0] = new TGeoCombiTrans( 0.5*triangleHeight*
 909                                       TMath::Tan(halfTheta),
 910                                       fgkLadderBeamRadius/2. - dy,
 911                                       -3*fgkSegmentLength/8, beamRot1);
 912
 913   beamTransf[1] = new TGeoCombiTrans( 0.5*triangleHeight*
 914                                       TMath::Tan(halfTheta),
 915                                       fgkLadderBeamRadius/2. - dy,
 916                                       -3*fgkSegmentLength/8, beamRot1);
 917   AddTranslationToCombiTrans(beamTransf[1], 0, 0, fgkSegmentLength/2);
 918
 919   beamTransf[2] = new TGeoCombiTrans(0.5*triangleHeight*
 920                                      TMath::Tan(halfTheta),
 921                                      fgkLadderBeamRadius/2. - dy,
 922                                      -fgkSegmentLength/8, beamRot2);
 923
 924   beamTransf[3] = new TGeoCombiTrans(0.5*triangleHeight*
 925                                      TMath::Tan(halfTheta),
 926                                      fgkLadderBeamRadius/2. - dy,
 927                                      -fgkSegmentLength/8, beamRot2);
 928   AddTranslationToCombiTrans(beamTransf[3], 0, 0, fgkSegmentLength/2);
 929
 930   beamTransf[4] = new TGeoCombiTrans(-0.5*triangleHeight*
 931                                      TMath::Tan(halfTheta),
 932                                      fgkLadderBeamRadius/2. - dy,
 933                                      -3*fgkSegmentLength/8, beamRot3);
 934
 935   beamTransf[5] = new TGeoCombiTrans(-0.5*triangleHeight*
 936                                      TMath::Tan(halfTheta),
 937                                      fgkLadderBeamRadius/2. - dy,
 938                                      -3*fgkSegmentLength/8, beamRot3);
 939   AddTranslationToCombiTrans(beamTransf[5], 0, 0, fgkSegmentLength/2);
 940
 941   beamTransf[6] = new TGeoCombiTrans(-0.5*triangleHeight*
 942   TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy, -fgkSegmentLength/8,beamRot4);
 943   beamTransf[7] = new TGeoCombiTrans(-0.5*triangleHeight*
 944   TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy,3*fgkSegmentLength/8,beamRot4);
 945
 946   //--- Beams of the bottom
 947   TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
 948                                  fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
 949   TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
 950                                    bottomBeam1, carbonFiberLadderStruct);
 951   bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
 952   TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
 953                                  fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
 954   TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
 955                                bottomBeam2, carbonFiberLadderStruct);
 956   bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
 957   TGeoTubeSeg *bottomBeam3 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
 958                              0.5*fgkLadderWidth/SinD(fgkBottomBeamAngle)
 959                              - fgkLadderLb/3, 0, 180);
 960   TGeoVolume *bottomBeam3Vol = new TGeoVolume("ITSsddBottomBeam3Vol",
 961                                    bottomBeam3, carbonFiberLadderStruct);
 962   bottomBeam3Vol->SetLineColor(fColorCarbonFiber);
 963   //bottomBeam3Vol->SetLineColor(2);
 964   TGeoRotation *bottomBeamRot1 = new TGeoRotation("", 90, 90,  90);
 965   TGeoRotation *bottomBeamRot2 = new TGeoRotation("",-90, 90, -90);
 966
 967   TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans
 968     (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,0, bottomBeamRot1);
 969   TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
 970                                       -(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,
 971                                       -fgkSegmentLength/2, bottomBeamRot1);
 972   TGeoCombiTrans *bottomBeamTransf3 = new TGeoCombiTrans(0,
 973                                       -(fgkLadderHeight/2 - fgkLadderBeamRadius)
 974                                       - dy, fgkSegmentLength/2, bottomBeamRot2);
 975   // be careful for beams #3: when "reading" from -z to +z and
 976   // from the bottom of the ladder, it should draw a Lambda, and not a V
 977   TGeoRotation *bottomBeamRot4 = new TGeoRotation("", -90, fgkBottomBeamAngle, -90);
 978   TGeoRotation *bottomBeamRot5 = new TGeoRotation("" ,-90,-fgkBottomBeamAngle, -90);
 979   TGeoCombiTrans *bottomBeamTransf4 = new TGeoCombiTrans
 980     (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,-fgkSegmentLength/4,bottomBeamRot4);
 981   TGeoCombiTrans *bottomBeamTransf5 = new TGeoCombiTrans
 982     (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,fgkSegmentLength/4, bottomBeamRot5);
 983
 984   fLaddSegCommonVol[0] = cfLaddTopVol1;  fLaddSegCommonTr[0] = trTop1;
 985   fLaddSegCommonVol[1] = cfLaddTopVol2;  fLaddSegCommonTr[1] = trTop1;
 986   fLaddSegCommonVol[2] = cfLaddSideVol1; fLaddSegCommonTr[2] = ctSideR;
 987   fLaddSegCommonVol[3] = cfLaddSideVol1; fLaddSegCommonTr[3] = ctSideL;
 988   fLaddSegCommonVol[4] = cfLaddSideVol2; fLaddSegCommonTr[4] = ctSideR;
 989   fLaddSegCommonVol[5] = cfLaddSideVol2; fLaddSegCommonTr[5] = ctSideL;
 990   fLaddSegCommonVol[6] = sideBeam;       fLaddSegCommonTr[6] = beamTransf[0];
 991   fLaddSegCommonVol[7] = sideBeam;       fLaddSegCommonTr[7] = beamTransf[1];
 992   fLaddSegCommonVol[8] = sideBeam;       fLaddSegCommonTr[8] = beamTransf[2];
 993   fLaddSegCommonVol[9] = sideBeam;       fLaddSegCommonTr[9] = beamTransf[3];
 994   fLaddSegCommonVol[10]= sideBeam;       fLaddSegCommonTr[10]= beamTransf[4];
 995   fLaddSegCommonVol[11]= sideBeam;       fLaddSegCommonTr[11]= beamTransf[5];
 996   fLaddSegCommonVol[12]= sideBeam;       fLaddSegCommonTr[12]= beamTransf[6];
 997   fLaddSegCommonVol[13]= sideBeam;       fLaddSegCommonTr[13]= beamTransf[7];
 998   fLaddSegCommonVol[14]= bottomBeam1Vol; fLaddSegCommonTr[14]= bottomBeamTransf1;
 999   fLaddSegCommonVol[15]= bottomBeam2Vol; fLaddSegCommonTr[15]= bottomBeamTransf2;
1000   fLaddSegCommonVol[16]= bottomBeam2Vol; fLaddSegCommonTr[16]= bottomBeamTransf3;
1001   fLaddSegCommonVol[17]= bottomBeam3Vol; fLaddSegCommonTr[17]= bottomBeamTransf4;
1002   fLaddSegCommonVol[18]= bottomBeam3Vol; fLaddSegCommonTr[18]= bottomBeamTransf5;
1003
1004
1005   //********************************************************************
1006   // cables
1007   //********************************************************************
1008   char cableName[30];
1009   for (Int_t i=0; i<fgkLay3Ndet; i++) {
1010     snprintf(cableName, 30, "digitCableLay3A_%i",i);
1011     fDigitCableLay3A[i].SetName(cableName);
1012     fDigitCableLay3A[i].SetWidth(fgkDigitCablWidth);
1013     fDigitCableLay3A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1014     fDigitCableLay3A[i].SetNLayers(2);
1015     fDigitCableLay3A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1016                                   fColorPolyhamide);
1017     fDigitCableLay3A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1018     snprintf(cableName, 30, "digitCableLay3B_%i",i);
1019     fDigitCableLay3B[i].SetName(cableName);
1020     fDigitCableLay3B[i].SetWidth(fgkDigitCablWidth);
1021     fDigitCableLay3B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1022     fDigitCableLay3B[i].SetNLayers(2);
1023     fDigitCableLay3B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1024                                   fColorPolyhamide);
1025     fDigitCableLay3B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1026   };
1027   for (Int_t i=0; i<fgkLay4Ndet; i++) {
1028     snprintf(cableName, 30, "digitCableLay4A_%i",i);
1029     fDigitCableLay4A[i].SetName(cableName);
1030     fDigitCableLay4A[i].SetWidth(fgkDigitCablWidth);
1031     fDigitCableLay4A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1032     fDigitCableLay4A[i].SetNLayers(2);
1033     fDigitCableLay4A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1034                                   fColorPolyhamide);
1035     fDigitCableLay4A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1036     snprintf(cableName, 30, "digitCableLay4B_%i",i);
1037     fDigitCableLay4B[i].SetName(cableName);
1038     fDigitCableLay4B[i].SetWidth(fgkDigitCablWidth);
1039     fDigitCableLay4B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1040     fDigitCableLay4B[i].SetNLayers(2);
1041     fDigitCableLay4B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1042                                   fColorPolyhamide);
1043     fDigitCableLay4B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1044   };
1045                                         // Well, those digit cables could also include the analog cables
1046                                         // which have the same width and the same path, at least in the ladder.
1047                                         // It will gain some computing ressources (less volumes) and some
1048                                         // coding efforts ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1049                                         // The only thing to do is to change the names and put the correct total
1050                                         // thicknesses
1051
1052   // some transformations and volumes used in several places
1053   fCommonTr[0] = new TGeoRotation("CarlosSuppRotN",
1054                                   0, -fgkCarlosSuppAngle, 0);
1055
1056   TGeoTube *littleScrewHead = new TGeoTube("littleScrewHead", 0, fgkLittleScrewHeadR,
1057                                            fgkLittleScrewHeadH/2);
1058   fCommonVol[0] = new TGeoVolume("vLittleScrewHead",
1059                                  littleScrewHead, stainless);
1060   fCommonVol[0]->SetLineColor(kGray);
1061
1062   fLadderFoot = CreateLadderFoot();
1063   CreateLVCard();
1064   fCardHV     = CreateHVCard(0);
1065   fCardCarlos = CreateCarlosCard(0);
1066
1067   //==================
1068   // link beteen phynox and plastic cooling tubes
1069   //==================
1070
1071   fRaccordoL = new TGeoVolumeAssembly("RaccordoL");
1072   Double_t fullRacLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
1073   TGeoTube *waterRac = new TGeoTube("waterRac", 0, fgkConnectorCoolTubeRmin, fullRacLen/2);
1074   TGeoVolume * vwaterRac = new TGeoVolume("vwaterRac", waterRac, coolerMediumSDD);
1075   vwaterRac->SetLineColor(kBlue);
1076
1077   TGeoTube *tube1Rac = new TGeoTube("tube1Rac", fgkConnectorCoolTubeRmin,
1078                                     fgkConnectorCoolTubeR1, fgkConnectorCoolTubeL1/2);
1079   TGeoTube *tube2Rac = new TGeoTube("tube2Rac", fgkConnectorCoolTubeRmin,
1080                                     fgkConnectorCoolTubeR2, fgkConnectorCoolTubeL2/2);
1081   TGeoTube *tube3Rac = new TGeoTube("tube3Rac", fgkConnectorCoolTubeRmin,
1082                                     fgkConnectorCoolTubeR3, fgkConnectorCoolTubeL3/2);
1083   TGeoVolume *  vtube1Rac = new TGeoVolume("vtube1Rac", tube1Rac, raccordMedium);
1084   TGeoVolume *  vtube2Rac = new TGeoVolume("vtube2Rac", tube2Rac, raccordMedium);
1085   TGeoVolume *  vtube3Rac = new TGeoVolume("vtube3Rac", tube3Rac, raccordMedium);
1086   vtube1Rac->SetLineColor(kGray);
1087   vtube2Rac->SetLineColor(kGray);
1088   vtube3Rac->SetLineColor(kGray);
1089
1090   TGeoTranslation *trTube1Rac = new TGeoTranslation("trTube1Rac",0,0,
1091                                                     -fullRacLen/2+fgkConnectorCoolTubeL1/2);
1092   TGeoTranslation *trTube2Rac = new TGeoTranslation("trTube2Rac",0,0,
1093                                (-fullRacLen/2+fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2/2));
1094   TGeoTranslation *trTube3Rac = new TGeoTranslation("trTube3Rac",0,0,
1095                                     (-fullRacLen/2+fgkConnectorCoolTubeL1+
1096                                      fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3/2));
1097   fRaccordoL->AddNode(vwaterRac, 1,0);
1098   fRaccordoL->AddNode(vtube1Rac, 1,trTube1Rac);
1099   fRaccordoL->AddNode(vtube2Rac, 1,trTube2Rac);
1100   fRaccordoL->AddNode(vtube3Rac, 1,trTube3Rac);
1101 }
1102
1103
1104 //________________________________________________________________________
1105 void AliITSv11GeometrySDD::CheckOverlaps(Double_t precision){
1106   //
1107   // a debugging function for checking some possible overlaps
1108   //
1109   if (fSDDsensor3)        fSDDsensor3->CheckOverlaps(precision);
1110   if (fSDDsensor4)        fSDDsensor4->CheckOverlaps(precision);
1111   if (fHybrid)            fHybrid->CheckOverlaps(precision);
1112 }
1113
1114
1115 //________________________________________________________________________
1116 TGeoCombiTrans *AliITSv11GeometrySDD::
1117 CreateCombiTrans(const char *name, Double_t dy, Double_t dz, Double_t dphi,
1118                  Bool_t planeSym) {
1119     //
1120     // return the TGeoCombiTrans which make a translation in y and z
1121     // and a rotation in phi in the global coord system
1122     // If planeSym = true, the rotation places the object symetrically
1123     // (with respect to the transverse plane) to its position in the
1124     // case planeSym = false
1125     //
1126
1127     TGeoTranslation t1(dy*CosD(90.+dphi),dy*SinD(90.+dphi), dz);
1128     TGeoRotation r1("",0.,0.,dphi);
1129     TGeoRotation r2("",90, 180, -90-dphi);
1130
1131     TGeoCombiTrans *combiTrans1 = new TGeoCombiTrans(name);
1132     combiTrans1->SetTranslation(t1);
1133     if (planeSym) combiTrans1->SetRotation(r1);
1134     else  combiTrans1->SetRotation(r2);
1135     return combiTrans1;
1136 }
1137
1138
1139 //________________________________________________________________________
1140 void AliITSv11GeometrySDD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
1141                                                        Double_t dx,
1142                                                        Double_t dy,
1143                                                        Double_t dz) const{
1144   // Add a dx,dy,dz translation to the initial TGeoCombiTrans
1145   const Double_t *vect = ct->GetTranslation();
1146   Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
1147   ct->SetTranslation(newVect);
1148 }
1149
1150
1151 //________________________________________________________________________
1152 void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
1153 // for code developpment and debugging purposes
1154
1155   if (! fSDDsensor3) CreateBasicObjects();
1156
1157   //  moth->AddNode(fPinSupport, 1, 0);
1158   //  moth->AddNode(fCoolPipeSupportL, 1, 0);
1159   //  moth->AddNode(fSDDsensor3, 1, 0);
1160   //  moth->AddNode(fSDDsensor4, 1, 0);
1161   //  moth->AddNode(fBaseThermalBridge, 1, 0);
1162   //  moth->AddNode(fHybrid,100,0);
1163   //  moth->AddNode(fLadderFoot,1,0);
1164   //moth->AddNode(fCardLVL,1,0);
1165   //moth->AddNode(fCardLVR,1,0);
1166
1167    TGeoVolume* seg = CreateLadderSegment( 3, 0);
1168    moth->AddNode(seg, 1, 0);
1169
1170 //   TGeoVolumeAssembly *lay3Ladder = CreateLadder(3);
1171 //   moth->AddNode(lay3Ladder, 1, 0);
1172
1173 //   TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1174 //   moth->AddNode(lay3Detectors, 1, 0);
1175
1176 //   TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1177 //   moth->AddNode(lay3Detectors, 1, 0);
1178
1179
1180 //   TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 );
1181 //   moth->AddNode(endLadder, 1, 0);
1182
1183 //   TGeoVolumeAssembly *highVCard = CreateHVCard( 4 );
1184 //   moth->AddNode(highVCard, 1, 0);
1185
1186 //   TGeoVolumeAssembly *supportRing = CreateSupportRing( 4 );
1187 //   moth->AddNode(supportRing, 1, 0);
1188
1189 //   TGeoVolume *endLadderCards = CreateEndLadderCardsV( 4 );
1190 //   moth->AddNode(endLadderCards, 1, 0);
1191
1192 //   TGeoVolumeAssembly *carlosCard = CreateCarlosCard( 4 );
1193 //   moth->AddNode(carlosCard, 1, 0);
1194
1195
1196
1197   /*
1198   //==================================
1199   //--- test of flat cable curvature
1200   //==================================
1201
1202   double angle = 90;
1203   AliITSv11GeomCableFlat cable("test", 3, 0.3);
1204   cable.SetNLayers(1);
1205   cable.SetNLayers(2);
1206   cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
1207   cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
1208   cable.SetInitialNode(endLadderCards);
1209
1210   Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
1211
1212   p1[0] = -3;
1213   p1[1] = 1;
1214   p1[2] = 10;
1215
1216   p2[0] = 0;
1217   p2[1] = 1;
1218   p2[2] = 10;
1219   cable.AddCheckPoint(endLadderCards, 0, p1, vX);
1220   cable.AddCheckPoint(endLadderCards, 1, p2, vX);
1221   cable.CreateAndInsertBoxCableSegment(1,angle);
1222
1223   Double_t p3[3], p4[3];
1224
1225   p3[0] = 2;
1226   p3[1] = 3;
1227   p3[2] = 10;
1228   cable.AddCheckPoint(endLadderCards, 2, p3, vY);
1229   cable.CreateAndInsertCableCylSegment(2,angle);
1230
1231   p4[0] = 2;
1232   p4[1] = 6;
1233   p4[2] = 10;
1234   cable.AddCheckPoint(endLadderCards, 3, p4, vY);
1235   cable.CreateAndInsertCableSegment(3,angle);
1236   */
1237 }
1238
1239
1240 //________________________________________________________________________
1241 void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) {
1242   //
1243   // Insert the layer 3 in the mother volume. This is a virtual volume
1244   // containing ladders of layer 3 and the supporting rings
1245   //
1246
1247   if (! moth) {
1248     printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1249     return;
1250   };
1251
1252   TGeoMedium *airSDD = GetMedium("SDD AIR$");
1253
1254   fMotherVol = moth;
1255   if (! fSDDsensor3) CreateBasicObjects();
1256
1257   //====================================
1258   // First we create the central barrel
1259   //====================================
1260
1261   TGeoVolumeAssembly *lay3Ladder    = CreateLadder(3);
1262   TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1263   TGeoVolumeAssembly *lay3Ladd2Det  = CreateDetectorsAssemblyLadd2();
1264   //TGeoVolume *lay3Detectors = CreateDetectors(3);
1265   TGeoTube *virtualLayer3Shape = new TGeoTube("ITSsddLayer3Shape",
1266                                      fgkLay3Rmin,fgkLay3Rmax,fgkLay3Length*0.5);
1267   TGeoVolume *virtualLayer3 = new TGeoVolume("ITSsddLayer3",
1268                                              virtualLayer3Shape, airSDD);
1269
1270   Double_t dPhi = 360./fgkLay3Nladd;
1271   Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
1272   // Placing virtual ladder and detectors volumes following
1273   // ladder ordering convention
1274   char rotName[30];
1275   Int_t iLaddMin = 0;
1276   Int_t iLaddMax = fgkLay3Nladd;
1277   if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1278     iLaddMin = fAddOnlyLadder3min;
1279     iLaddMax = fAddOnlyLadder3max+1;
1280   };
1281
1282   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1283
1284     Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1285     snprintf(rotName, 30, "ITSsddLay3Ladd%i",iLadd);
1286     Double_t minRadiusLadBox = fLay3LaddShortRadius-fLay3LadderUnderSegDH;
1287     if (iLadd%2 != 0)
1288       minRadiusLadBox = fLay3LaddLongRadius-fLay3LadderUnderSegDH;
1289     minRadiusLadBox += ((TGeoBBox*)lay3Ladder->GetShape())->GetDY();
1290     TGeoCombiTrans *ctLadd;
1291     //=============================================================
1292     //
1293     //   Special modification  for ladder 2 of layer 3:
1294     //   It has been inverted (pi rotation around y axis)
1295     //
1296     //=============================================================
1297     if (iLadd != 2)
1298       ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
1299                                 0, ladderPhi, kTRUE);
1300     else
1301       ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
1302                                 0, ladderPhi, kFALSE);
1303     virtualLayer3->AddNode(lay3Ladder, iLadd, ctLadd);
1304     ///////////////////////////////////////////////////
1305     snprintf(rotName, 30, "ITSsddLay3DetBox%i",iLadd);
1306     Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1307     if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1308     minRadiusDetBox += detectorsThick/2;
1309     TGeoCombiTrans *ctDet;
1310     ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
1311                              0, ladderPhi, kTRUE);
1312
1313     if (iLadd != 2)
1314       virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet);
1315     else
1316       virtualLayer3->AddNode(lay3Ladd2Det , iLadd, ctDet);
1317
1318     ///////////////////////////////////////////////////
1319   }
1320
1321   /*
1322   //====================================
1323   // Then the forward rapidity pieces
1324   // (cooling, Carlos, LV, HV ...)
1325   //====================================
1326
1327   Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm;  // this has to be tune
1328   Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
1329   Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
1330
1331   TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
1332   TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
1333                                                 fgkForwardLay3Rmin, fgkForwardLay3Rmax,
1334                                                 fgkForwardLay3Length/2.);
1335
1336 //   TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
1337 // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
1338 //   virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
1339
1340
1341   TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
1342                                                   virtualForward3Shape, airSDD);
1343   TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
1344                                                   virtualForward3Shape, airSDD);
1345 //   TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1346 //   TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1347
1348   TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
1349                                           fgkLay3Length/2+fgkForwardLay3Length/2);
1350   TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
1351                                           -fgkLay3Length/2-fgkForwardLay3Length/2);
1352
1353   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1354
1355     Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1356     Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1357     if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1358     minRadiusDetBox += detectorsThick/2;
1359
1360     sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
1361
1362     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1363                                    -fgkForwardLay3Length/2, ladderPhi, kTRUE);
1364     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1365                                    fgkForwardLay3Length/2, ladderPhi, kFALSE);
1366
1367     virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1368     virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1369   }
1370
1371   */
1372
1373
1374   if(GetDebug(1)) {
1375     virtualLayer3->CheckOverlaps(0.01);
1376     //virtualForward3Pos->CheckOverlaps(0.01);
1377     //virtualForward3Neg->CheckOverlaps(0.01);
1378   }
1379
1380   virtualLayer3->SetVisibility(kFALSE);
1381   //virtualForward3Pos->SetVisibility(kFALSE);
1382   //virtualForward3Neg->SetVisibility(kFALSE);
1383
1384
1385   moth->AddNode(virtualLayer3, 1, 0);
1386   //moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
1387   //moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
1388 }
1389
1390
1391 // //________________________________________________________________________
1392 // void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
1393 //   //
1394 //   // Insert the forward pieces of layer 3 in the mother volume.
1395 //   // (cooling, Carlos, LV, HV ...)
1396 //   //
1397
1398 //   if (! moth) {
1399 //     printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1400 //     return;
1401 //   };
1402
1403 //   TGeoMedium *airSDD = GetMedium("SDD AIR$");
1404
1405 //   if (! fSDDsensor3) CreateBasicObjects();
1406
1407 //   Double_t dPhi = 360./fgkLay3Nladd;
1408 //   Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
1409 //   Int_t iLaddMin = 0;
1410 //   Int_t iLaddMax = fgkLay3Nladd;
1411 //   if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1412 //     iLaddMin = fAddOnlyLadder3min;
1413 //     iLaddMax = fAddOnlyLadder3max+1;
1414 //   };
1415 //   char rotName[30];
1416
1417
1418 //   //=================
1419
1420 //   Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm;  // this has to be tune
1421 //   Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
1422 //   Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
1423
1424 //   TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
1425 //   TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
1426 //                                              fgkForwardLay3Rmin, fgkForwardLay3Rmax,
1427 //                                              fgkForwardLay3Length/2.);
1428
1429 // //   TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
1430 // // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
1431 // //   virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
1432
1433
1434 //   TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
1435 //                                                virtualForward3Shape, airSDD);
1436 //   TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
1437 //                                                virtualForward3Shape, airSDD);
1438 // //   TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1439 // //   TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1440
1441 //   TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
1442 //                                        fgkLay3Length/2+fgkForwardLay3Length/2);
1443 //   TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
1444 //                                        -fgkLay3Length/2-fgkForwardLay3Length/2);
1445
1446 //   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1447
1448 //     Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1449 //     Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1450 //     if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1451 //     minRadiusDetBox += detectorsThick/2;
1452
1453 //     sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
1454
1455 //     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1456 //                                 -fgkForwardLay3Length/2, ladderPhi, kTRUE);
1457 //     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1458 //                                 fgkForwardLay3Length/2, ladderPhi, kFALSE);
1459
1460 //     virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1461 //     virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1462 //   }
1463
1464 //   if(GetDebug(1)) {
1465 //     virtualForward3Pos->CheckOverlaps(0.01);
1466 //     virtualForward3Neg->CheckOverlaps(0.01);
1467 //   }
1468
1469 //   virtualForward3Pos->SetVisibility(kFALSE);
1470 //   virtualForward3Neg->SetVisibility(kFALSE);
1471
1472 //   moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
1473 //   moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
1474 // }
1475
1476
1477
1478 //________________________________________________________________________
1479 void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
1480   //
1481   // Insert the end-ladder of layer 3 in the mother volume.
1482   // (cooling, Carlos, LV, HV ...)
1483   //
1484
1485   if (! moth) {
1486     printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1487     return;
1488   };
1489
1490   if (! fSDDsensor3) CreateBasicObjects();
1491
1492   Int_t iLaddMin = 0;
1493   Int_t iLaddMax = fgkLay3Nladd;
1494   if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1495     iLaddMin = fAddOnlyLadder3min;
1496     iLaddMax = fAddOnlyLadder3max+1;
1497   };
1498
1499   TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1500   TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1501
1502   char rotName[30];
1503   Double_t dPhi = 360./fgkLay3Nladd;
1504   TGeoVolume* lay3EndLadder = CreateEndLadderCardsV(3);
1505
1506   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1507
1508     Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1509     Double_t dR = 0;
1510     if (iLadd%2 != 0) dR = fgkLay3DetLongRadius-fgkLay3DetShortRadius;
1511
1512     snprintf(rotName, 30, "ITSsddLay3EndLadd%i",iLadd);
1513
1514     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
1515                                     fgkLay3Length/2, ladderPhi, kTRUE);
1516     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
1517                                    -fgkLay3Length/2, ladderPhi, kFALSE);
1518
1519     virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1520     virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1521   }
1522
1523   if(GetDebug(1)) {
1524     virtualForward3Pos->CheckOverlaps(0.01);
1525     virtualForward3Neg->CheckOverlaps(0.01);
1526   }
1527
1528   // 180deg Y rotation to compensate the cancellation of ITSD volume
1529   // (idortm[199] in AliITSv11Hybrid : z--->  -z;   x ---> -x;   y ---> y)
1530   TGeoRotation *y180 = new TGeoRotation();
1531   y180->SetAngles( 90.,180., 90., 90.,180.,  0.);
1532   moth->AddNode(virtualForward3Pos, 1, y180);
1533   moth->AddNode(virtualForward3Neg, 1, y180);
1534 }
1535
1536 //________________________________________________________________________
1537 void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
1538   //
1539   // Insert the layer 4 in the mother volume. This is a virtual volume
1540   // containing ladders of layer 4 and the supporting rings
1541   //
1542
1543   if (! moth) {
1544     printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1545     return;
1546   };
1547
1548   fMotherVol = moth;
1549
1550   if (! fSDDsensor3) CreateBasicObjects();
1551
1552   TGeoTube *virtualLayer4Shape =new TGeoTube("ITSsddLayer4Shape",
1553                                     fgkLay4Rmin,fgkLay4Rmax,fgkLay4Length*0.5);
1554   TGeoMedium *airSDD = GetMedium("SDD AIR$");
1555   TGeoVolume *virtualLayer4 = new TGeoVolume("ITSsddLayer4",
1556                                              virtualLayer4Shape, airSDD);
1557
1558   //====================================
1559   // First we create the central barrel
1560   //====================================
1561
1562    TGeoVolumeAssembly *lay4Ladder    = CreateLadder(4);
1563   //TGeoVolume *lay4Detectors = CreateDetectors(4);
1564   TGeoVolumeAssembly *lay4Detectors = CreateDetectorsAssembly(4);
1565
1566   Double_t dPhi = 360./fgkLay4Nladd;
1567   Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
1568
1569   // placing virtual ladder and detectors volumes following ladder
1570   // ordering convention
1571   char rotName[30];
1572   Int_t iLaddMin = 0;
1573   Int_t iLaddMax = fgkLay4Nladd;
1574   if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1575     iLaddMin = fAddOnlyLadder4min;
1576     iLaddMax = fAddOnlyLadder4max+1;
1577   }
1578   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1579
1580     Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1581     snprintf(rotName, 30, "ITSsddLay4Ladd%i",iLadd);
1582     Double_t minRadiusLadBox = fLay4LaddShortRadius-fLay4LadderUnderSegDH;
1583     if (iLadd%2 != 0)
1584       minRadiusLadBox = fLay4LaddLongRadius-fLay4LadderUnderSegDH;
1585     minRadiusLadBox += ((TGeoBBox*)lay4Ladder->GetShape())->GetDY();
1586     TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName, minRadiusLadBox,
1587                                               0, ladderPhi, kTRUE);
1588     virtualLayer4->AddNode(lay4Ladder, iLadd, ctLadd);
1589     ///////////////////////////////////////////////////
1590     snprintf(rotName, 30, "ITSsddLay4DetBox%i",iLadd);
1591     Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1592     if (iLadd%2 != 0)
1593       minRadiusDetBox = fgkLay4DetLongRadius;
1594     minRadiusDetBox += detBoxThickness/2;
1595     TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
1596                                              0, ladderPhi, kTRUE);
1597     virtualLayer4->AddNode(lay4Detectors, iLadd, ctDet);
1598     ///////////////////////////////////////////////////
1599   }
1600
1601   /*
1602   //====================================
1603   // Then the pieces at forward rapidity
1604   // (cooling, Carlos, LV, HV ...)
1605   //====================================
1606
1607   Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm;  // this has to be tuned
1608   Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
1609   Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
1610
1611   TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
1612   TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
1613                                                 fgkForwardLay4Rmin, fgkForwardLay4Rmax,
1614                                                 fgkForwardLay4Length/2.);
1615   TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
1616                                                   virtualForward4Shape, airSDD);
1617   TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
1618                                                   virtualForward4Shape, airSDD);
1619 //   TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1620 //   TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1621
1622   TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
1623                                           fgkLay4Length/2+fgkForwardLay4Length/2);
1624   TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
1625                                           -fgkLay4Length/2-fgkForwardLay4Length/2);
1626
1627   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1628
1629     Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1630     Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1631     if (iLadd%2 != 0)
1632       minRadiusDetBox = fgkLay4DetLongRadius;
1633     minRadiusDetBox += detBoxThickness/2;
1634
1635     sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
1636
1637     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1638                                    -fgkForwardLay4Length/2, ladderPhi, kTRUE);
1639     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1640                                     fgkForwardLay4Length/2, ladderPhi, kFALSE);
1641     virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1642     virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
1643   }
1644   */
1645
1646   if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01);
1647
1648   virtualLayer4->SetVisibility(kFALSE);
1649   //virtualForward4Pos->SetVisibility(kFALSE);
1650   //virtualForward4Neg->SetVisibility(kFALSE);
1651
1652   moth->AddNode(virtualLayer4,1,0);
1653   //moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
1654   //moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
1655 }
1656
1657
1658 // //________________________________________________________________________
1659 // void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
1660 //   //
1661 //   // Insert the layer 4 in the mother volume. This is a virtual volume
1662 //   // containing ladders of layer 4 and the supporting rings
1663 //   // (cooling, Carlos, LV, HV ...)
1664 //   //
1665
1666 //   if (! moth) {
1667 //     printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1668 //     return;
1669 //   };
1670
1671 //   TGeoMedium *airSDD = GetMedium("SDD AIR$");
1672
1673 //   if (! fSDDsensor3) CreateBasicObjects();
1674
1675 //   Double_t dPhi = 360./fgkLay4Nladd;
1676 //   Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
1677
1678 //   // placing virtual ladder and detectors volumes following ladder
1679 //   // ordering convention
1680 //   char rotName[20];
1681 //   Int_t iLaddMin = 0;
1682 //   Int_t iLaddMax = fgkLay4Nladd;
1683 //   if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1684 //     iLaddMin = fAddOnlyLadder4min;
1685 //     iLaddMax = fAddOnlyLadder4max+1;
1686 //   }
1687
1688 //   //=================
1689 //   Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm;  // this has to be tuned
1690 //   Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
1691 //   Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
1692
1693 //   TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
1694 //   TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
1695 //                                              fgkForwardLay4Rmin, fgkForwardLay4Rmax,
1696 //                                              fgkForwardLay4Length/2.);
1697 //   TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
1698 //                                                virtualForward4Shape, airSDD);
1699 //   TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
1700 //                                                virtualForward4Shape, airSDD);
1701 // //   TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1702 // //   TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1703
1704 //   TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
1705 //                                        fgkLay4Length/2+fgkForwardLay4Length/2);
1706 //   TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
1707 //                                        -fgkLay4Length/2-fgkForwardLay4Length/2);
1708
1709 //   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1710
1711 //     Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1712 //     Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1713 //     if (iLadd%2 != 0)
1714 //       minRadiusDetBox = fgkLay4DetLongRadius;
1715 //     minRadiusDetBox += detBoxThickness/2;
1716
1717 //     sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
1718
1719 //     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1720 //                                 -fgkForwardLay4Length/2, ladderPhi, kTRUE);
1721 //     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1722 //                                  fgkForwardLay4Length/2, ladderPhi, kFALSE);
1723 //     virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1724 //     virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
1725 //   }
1726
1727 //   virtualForward4Pos->SetVisibility(kFALSE);
1728 //   virtualForward4Neg->SetVisibility(kFALSE);
1729
1730 //   moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
1731 //   moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
1732 // }
1733
1734
1735 //________________________________________________________________________
1736 void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
1737   //
1738   // Insert the end-ladder of layer 4 in the mother volume.
1739   // (cooling, Carlos, LV, HV ...)
1740   //
1741
1742   if (! moth) {
1743     printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1744     return;
1745   };
1746
1747   if (! fSDDsensor3) CreateBasicObjects();
1748
1749   // placing virtual ladder and detectors volumes following ladder
1750   // ordering convention
1751   Int_t iLaddMin = 0;
1752   Int_t iLaddMax = fgkLay4Nladd;
1753   if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1754     iLaddMin = fAddOnlyLadder4min;
1755     iLaddMax = fAddOnlyLadder4max+1;
1756   }
1757
1758   TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1759   TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1760
1761   char rotName[30];
1762   Double_t dPhi = 360./fgkLay4Nladd;
1763   TGeoVolume* lay4EndLadder = CreateEndLadderCardsV(4);
1764
1765   for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1766
1767     Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1768     Double_t dR = 0;
1769     if (iLadd%2 != 0)
1770       dR = fgkLay4DetLongRadius-fgkLay4DetShortRadius;
1771
1772     snprintf(rotName, 30, "ITSsddLay4EndLadd%i",iLadd);
1773
1774     TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
1775                                    fgkLay4Length/2, ladderPhi, kTRUE);
1776     TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
1777                                    -fgkLay4Length/2, ladderPhi, kFALSE);
1778     virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1779     virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2, ctEndLaddNeg);
1780   }
1781
1782   // 180deg Y rotation to compensate the cancellation of ITSD volume
1783   // (idortm[199] in AliITSv11Hybrid : z--->  -z;   x ---> -x;   y ---> y)
1784   TGeoRotation *y180 = new TGeoRotation();
1785   y180->SetAngles( 90.,180., 90., 90.,180.,  0.);
1786   moth->AddNode(virtualForward4Pos, 1, y180);
1787   moth->AddNode(virtualForward4Neg, 1, y180);
1788 }
1789
1790
1791 //________________________________________________________________________
1792 TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
1793   //
1794   // return an assembly volume containing the CF ladder
1795   //
1796
1797   Int_t    nDetectors   = fgkLay3Ndet;
1798   Double_t ladderLength = fgkLay3LadderLength;
1799   Double_t underSegDH   = fLay3LadderUnderSegDH;
1800   Double_t *sensorZPos  = fLay3sensorZPos;
1801   AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
1802   AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
1803
1804   if (iLay==3) {}
1805   else if (iLay==4) {
1806     nDetectors   = fgkLay4Ndet;
1807     ladderLength = fgkLay4LadderLength;
1808     digitCableA  = fDigitCableLay4A;
1809     digitCableB  = fDigitCableLay4B;
1810     underSegDH   = fLay4LadderUnderSegDH;
1811     sensorZPos   = fLay4sensorZPos;
1812   }
1813   else {
1814     printf("AliITSv11GeometrySDD::CreateLadder : error=wrong layer\n");
1815   };
1816   Double_t ladderBoxDH = fgkLadderHeight+fgkLadderSegBoxDH+underSegDH;
1817   TGeoVolumeAssembly *virtualLadder = new TGeoVolumeAssembly("ITSsddLadder");
1818
1819   // placing virtual ladder segment following detector ordering convention
1820   //=======================================================================
1821   char transName[30];
1822
1823   // adding segment this way to create cable points in the correct order ...
1824   for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
1825
1826     //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
1827     TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
1828     snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
1829     Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
1830                           + fgkSegmentLength/2;
1831     TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
1832                                                  underSegDH/2,segmentPos);
1833     ////
1834     virtualLadder->AddNode(laddSegment, iSegment, segTr);
1835   };
1836   for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
1837
1838     TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
1839     //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
1840     snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
1841     Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
1842                           + fgkSegmentLength/2;
1843     TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
1844                                                  underSegDH/2,segmentPos);
1845     ////
1846     virtualLadder->AddNode(laddSegment, iSegment, segTr);
1847   };
1848
1849   // putting virtual volume corresponding to the end of ladder
1850   //=======================================================================
1851   TGeoVolumeAssembly *endLadder = CreateEndLadder( iLay );
1852   Double_t endLength = (ladderLength - nDetectors*fgkSegmentLength)/2.;
1853   TGeoTranslation *endTrZPos = new TGeoTranslation("ITSsddEndTrZPos",0,0,
1854                                    fgkSegmentLength*(nDetectors/2)+endLength/2.);
1855   // Euler rotation : about Z, then new X, then new Z
1856   TGeoRotation *endZNegRot = new TGeoRotation("",90, 180, -90);
1857   TGeoCombiTrans *endTrZNeg = new TGeoCombiTrans(0,0,
1858                   -fgkSegmentLength*(nDetectors/2)-endLength/2.,endZNegRot);
1859   virtualLadder->AddNode(endLadder, 1, endTrZPos);
1860   virtualLadder->AddNode(endLadder, 2, endTrZNeg);
1861
1862   // creating and inserting cable segments
1863   //   (check points are placed while creating segments)
1864   //=======================================================================
1865   if (fAddCables)
1866   for (Int_t iSegment = 0; iSegment < nDetectors; iSegment++ ) {
1867
1868     digitCableA[iSegment].SetInitialNode(virtualLadder);
1869     digitCableB[iSegment].SetInitialNode(virtualLadder);
1870
1871     for (Int_t iPt=1; iPt<digitCableA[iSegment].GetNCheckPoints(); iPt++ ) {
1872       Double_t rotation = 0;
1873       if (iPt>1) {
1874         rotation = 90-fgkHybridAngle;
1875         digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
1876       } else
1877         digitCableA[iSegment].CreateAndInsertCableSegment(iPt);
1878
1879     };
1880
1881     for (Int_t iPt=1; iPt<digitCableB[iSegment].GetNCheckPoints(); iPt++ ) {
1882       Double_t rotation = 0;
1883       if (iPt>1) {
1884         rotation = fgkHybridAngle-90;
1885         digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
1886       } else
1887         digitCableB[iSegment].CreateAndInsertCableSegment(iPt);
1888     };
1889   };
1890
1891   // HV cable
1892   //=======================================================================
1893   if (fAddHVcables) {
1894     TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$");  //ITSsddKAPTON_POLYCH2
1895     TGeoMedium *alSDD         = GetMedium("AL$");   //ITSal
1896
1897   AliITSv11GeomCableFlat cableHV[fgkLay4Ndet];  // temp !!!
1898   char cableHVname[30];
1899   for (Int_t iSegment = 0; iSegment<nDetectors; iSegment++) {
1900     snprintf(cableHVname,30,"ITSsddHVcable%i", iSegment);
1901     cableHV[iSegment].SetName(cableHVname);
1902     cableHV[iSegment].SetThickness(fgkLongHVcablePolyThick+fgkLongHVcableAlThick);
1903     cableHV[iSegment].SetWidth(fgkTransitHVtailWidth);
1904     cableHV[iSegment].SetNLayers(2);
1905     cableHV[iSegment].SetLayer(0, fgkLongHVcablePolyThick, polyhamideSDD,
1906                                fColorPolyhamide);
1907     cableHV[iSegment].SetLayer(1, fgkLongHVcableAlThick, alSDD, fColorAl);
1908     cableHV[iSegment].SetInitialNode(virtualLadder);
1909   };
1910   Double_t x1[3], x2[3], x3[3],
1911            vY[3] = {0,1,0}, vZ[3] = {0,0,1}, vYZ[3]={0,1,1};
1912
1913   x1[0] = -fgkTransitHVtailXpos;
1914   x2[0] = -fgkTransitHVtailXpos;
1915   x3[0] = -fgkTransitHVtailXpos;
1916   for (Int_t iSegment  = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
1917     Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
1918                                *fgkLongHVcableSeparation;
1919     // adjust where HV long cable starts in Y
1920     // useful if you want to let some space for alignment
1921     x1[1] = - ladderBoxDH/2 + 2*fgkmm;
1922     x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
1923             - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
1924     x3[1] = x2[1];
1925     x1[2] = sensorZPos[iSegment]+fgkTransitHVtailLength-5*fgkmm;
1926     x2[2] =  x1[2]+5*fgkmm;
1927     x3[2] = ladderLength/2-endLength;
1928     cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
1929     cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
1930     cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
1931
1932     //cableHV[iSegment].CreateAndInsertCableSegment(1,0);
1933     cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45+180);
1934     //cableHV[iSegment].CreateAndInsertCableSegment(2,0);
1935     cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
1936   };
1937
1938   vYZ[2] = -1;
1939   x1[0] = fgkTransitHVtailXpos;
1940   x2[0] = fgkTransitHVtailXpos;
1941   x3[0] = fgkTransitHVtailXpos;
1942
1943   for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
1944     Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
1945                                *fgkLongHVcableSeparation;
1946     x1[1] = - ladderBoxDH/2 + 2*fgkmm; // adjust where HV long cable starts in Y
1947     x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
1948             - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
1949     x3[1] = x2[1];
1950     x1[2] = sensorZPos[iSegment]-fgkTransitHVtailLength+5*fgkmm;
1951     x2[2] =  x1[2]-5*fgkmm;
1952     x3[2] = -ladderLength/2+endLength;
1953     cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
1954     cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
1955     cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
1956
1957     cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45);
1958     cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
1959   };
1960   };
1961
1962   //**********************************
1963   if(GetDebug(1)) virtualLadder->CheckOverlaps(0.01);
1964   return virtualLadder;
1965 }
1966
1967
1968 //________________________________________________________________________
1969 TGeoArb8 *AliITSv11GeometrySDD::CreateLadderSide(const char *name,
1970                          Double_t dz, Double_t angle, Double_t xSign,
1971                          Double_t L, Double_t H, Double_t l) {
1972     // Create one half of the V shape corner of CF ladder
1973
1974     TGeoArb8 *cfLaddSide = new TGeoArb8(dz);
1975     cfLaddSide->SetName(name);
1976
1977     // Points must be in clockwise order
1978     cfLaddSide->SetVertex(0, 0,  0);
1979     cfLaddSide->SetVertex(2, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1980                           -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1981     cfLaddSide->SetVertex(4, 0,  0);
1982     cfLaddSide->SetVertex(6, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1983                           -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1984     if (xSign < 0) {
1985      cfLaddSide->SetVertex(1, 0, -H);
1986      cfLaddSide->SetVertex(3, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
1987      cfLaddSide->SetVertex(5, 0, -H);
1988      cfLaddSide->SetVertex(7, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
1989     } else {
1990      cfLaddSide->SetVertex(1, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
1991      cfLaddSide->SetVertex(3, 0, -H);
1992      cfLaddSide->SetVertex(5, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
1993      cfLaddSide->SetVertex(7, 0, -H);
1994     }
1995     return cfLaddSide;
1996 }
1997
1998
1999 //________________________________________________________________________
2000 TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) {
2001   //
2002   // return a box containing the front-end hybrid
2003   //
2004
2005   Double_t roundHoleX       = -fgkHybridWidth/2+fgkHybRndHoleX;
2006
2007   Double_t screenTotalThick = fgkHybGlueScrnThick+fgkHybUpThick+fgkHybAlThick;
2008   Double_t lowFLTotalThick  = fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick;
2009 //   Double_t upFLTotalThick   = fgkHybGlueUpThick +fgkHybUpThick+fgkHybAlThick;
2010   Double_t chipsCCTotThick  = fgkHybUnderNiThick+fgkHybGlueAgThick
2011                               +fgkHybChipThick+2*(fgkHybUpCCThick+fgkHybAlCCThick);
2012   Double_t ccUpLayerTotThick = fgkHybUpCCThick+fgkHybAlCCThick+fgkHybUpCCThick;
2013 //   Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
2014 //                        + upFLTotalThick + ccUpLayerTotThick);
2015   Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
2016                           +fgkHybSMDheight);
2017   Double_t lowLayerYmin     = -volumeThick/2+fgkHybridThBridgeThick
2018                               +screenTotalThick;
2019   Double_t flUpThick        = fgkHybGlueUpThick+fgkHybUpThick;
2020
2021   //**************************************************** media :
2022   TGeoMedium *airSDD                  = GetMedium("SDD AIR$");
2023   TGeoMedium *carbonFiberLadderStruct = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddCarbonM55J
2024   TGeoMedium *alSDD                   = GetMedium("AL$"); //ITSal
2025   TGeoMedium *alSDD80p100             = GetMedium("AL$");                 // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2026   TGeoMedium *alSDD50p100             = GetMedium("AL$");                 // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2027   TGeoMedium *polyhamideSDD           = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddKAPTON_POLYCH2
2028   TGeoMedium *niSDD                   = GetMedium("NICKEL$");
2029   TGeoMedium *glueAG                  = GetMedium("SDDKAPTON (POLYCH2)$");  // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2030   TGeoMedium *siliconSDD              = GetMedium("SDD SI CHIP$"); //ITSsddSiChip
2031   TGeoMedium *medSMD                  = GetMedium("SDD X7R capacitors$"); //  SDDX7Rcapacitors
2032   TGeoMedium *medSMDweld              = GetMedium("SDD X7R weld$");
2033
2034   //**************************************************** main volume :
2035 //  TGeoBBox *hybridBox = new TGeoBBox("",fgkHybridWidth/2, volumeThick/2,
2036 //                                   (fgkHybridLength)/2);
2037   Double_t xhybr[6],yhybr[6];
2038   xhybr[0] = -fgkHybridWidth/2;
2039   yhybr[0] = -volumeThick/2;
2040   xhybr[1] =  fgkHybridWidth/2;
2041   yhybr[1] = -volumeThick/2;
2042   xhybr[2] =  fgkHybridWidth/2;
2043   yhybr[2] =  volumeThick/2;
2044   xhybr[3] = -fgkHybridWidth/2;
2045   yhybr[3] =  volumeThick/2;
2046   xhybr[4] =  xhybr[3] - 1.05*fgkHybCC2SensorLen*SinD(fgkHybCC2SensorAng);
2047   yhybr[4] =  yhybr[3] - 1.05*fgkHybCC2SensorLen*CosD(fgkHybCC2SensorAng);
2048   xhybr[5] =  xhybr[4];
2049   yhybr[5] =  yhybr[4] - volumeThick;
2050
2051   TGeoXtru *hybridBox = new TGeoXtru(2);
2052   hybridBox->DefinePolygon(6, xhybr, yhybr);
2053   hybridBox->DefineSection(0,-fgkHybridLength/2);
2054   hybridBox->DefineSection(1, fgkHybridLength/2);
2055
2056   TGeoVolume *hybrid = new TGeoVolume("ITSsddHybridVol", hybridBox,
2057                                       airSDD);
2058
2059   TGeoBBox *sThermalBridge = new TGeoBBox( "", fgkHybridWidth/2,
2060                                            fgkHybridThBridgeThick/2,
2061                                            fgkHybridLength/2);
2062
2063   //**************************************************** Thermal bridge :
2064   TGeoVolume *vThermalBridge = new TGeoVolume("ITSsddHybridThBridge",
2065                                               sThermalBridge,
2066                                               carbonFiberLadderStruct);
2067   vThermalBridge->SetLineColor(fColorCarbonFiber);
2068   TGeoTranslation *thBridgeTr = new TGeoTranslation(0, -volumeThick/2
2069                                     +fgkHybridThBridgeThick/2, 0);
2070   hybrid->AddNode(vThermalBridge, 1, thBridgeTr);
2071
2072   //**************************************************** Screen layer :
2073   TGeoBBox *sAlScreenLayer = new TGeoBBox("sAlScreenLayer", fgkHybridWidth/2,
2074                                           fgkHybAlThick/2, fgkHybridLength/2);
2075   //here the upedex and glue layers are both assumed to be polyimide
2076   TGeoBBox *sUpGlueScreenLayer = new TGeoBBox("sUpGlueScreenLayer",
2077                                               fgkHybridWidth/2,
2078                                      (fgkHybUpThick+fgkHybGlueScrnThick)/2,
2079                                               fgkHybridLength/2);
2080   TGeoTube *sRoundHole = new TGeoTube("sRoundHole", 0, fgkHybRndHoleRad,
2081                                       (screenTotalThick+lowFLTotalThick)/2);
2082
2083   TGeoTranslation *upGlueScreenTr = new TGeoTranslation("upGlueScreenTr",0,
2084    -volumeThick/2+fgkHybridThBridgeThick+(fgkHybUpThick+fgkHybGlueScrnThick)/2,0);
2085
2086   TGeoTranslation *alScreenTr = new TGeoTranslation("AlScreenTr", 0,
2087    -volumeThick/2+fgkHybridThBridgeThick+fgkHybUpThick+fgkHybGlueScrnThick
2088    +fgkHybAlThick/2, 0);
2089
2090   TGeoTranslation hybHolePos1Tr(roundHoleX,
2091    -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
2092                                 -fgkHybridLength/2+fgkHybRndHoleZ);
2093   TGeoTranslation hybHolePos2Tr(roundHoleX,
2094    -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
2095                                 fgkHybridLength/2-fgkHybRndHoleZ);
2096
2097   TGeoRotation *rotHole = new TGeoRotation("", 0, 90, 0);
2098   TGeoCombiTrans *hybHolePos1 = new TGeoCombiTrans(hybHolePos1Tr, *rotHole);
2099   hybHolePos1->SetName("hybHolePos1");
2100   TGeoCombiTrans *hybHolePos2 = new TGeoCombiTrans(hybHolePos2Tr, *rotHole);
2101   hybHolePos2->SetName("hybHolePos2");
2102
2103   upGlueScreenTr->RegisterYourself();
2104   alScreenTr->RegisterYourself();
2105   hybHolePos1->RegisterYourself();
2106   hybHolePos2->RegisterYourself();
2107   delete rotHole;
2108
2109   TGeoCompositeShape *sScreenAl = new TGeoCompositeShape(
2110                       "sAlScreenLayer:AlScreenTr-(sRoundHole:hybHolePos1"
2111                       "+sRoundHole:hybHolePos2)");
2112   TGeoVolume *vScreenAl = new TGeoVolume("vScreenAl",sScreenAl, alSDD);
2113   vScreenAl->SetLineColor(fColorAl);
2114   TGeoCompositeShape *sScreenUpGlue = new TGeoCompositeShape(
2115         "sUpGlueScreenLayer:upGlueScreenTr-(sRoundHole:hybHolePos1"
2116         "+sRoundHole:hybHolePos2)");
2117   TGeoVolume *vScreenUpGlue = new TGeoVolume("vScreenUpGlue",
2118                                              sScreenUpGlue,polyhamideSDD);
2119   vScreenUpGlue->SetLineColor(fColorPolyhamide);
2120
2121   hybrid->AddNode(vScreenUpGlue, 1, 0);
2122   hybrid->AddNode(vScreenAl, 1, 0);
2123
2124   //****************************************************  FL low layer :
2125   Double_t sideWidth1 = fgkHybFLlowChipZ1 - fgkHybFLlowHoleDZ/2;
2126   Double_t sideWidth2 = fgkHybridLength - fgkHybFLlowChipZ4 - fgkHybFLlowHoleDZ/2;
2127
2128   //here the upedex and glue layers are both assumed to be polyimide
2129   TGeoBBox *sUpGlueBar1 = new TGeoBBox("sUpGlueBar1", fgkHybridWidth/2,
2130                                       (fgkHybGlueLowThick+fgkHybUpThick)/2,
2131                                        sideWidth1/2);
2132   TGeoBBox *sAlBar1 = new TGeoBBox("sAlBar1", fgkHybridWidth/2,
2133                                   fgkHybAlThick/2, sideWidth1/2);
2134
2135   TGeoTranslation *upGlueBarTr1 = new TGeoTranslation("upGlueBarTr1", 0,
2136                               lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
2137                                               -(fgkHybridLength-sideWidth1)/2);
2138   TGeoTranslation *alBarTr1 = new TGeoTranslation("alBarTr1", 0,
2139                     lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
2140                                               -(fgkHybridLength-sideWidth1)/2);
2141   upGlueBarTr1->RegisterYourself();
2142   alBarTr1->RegisterYourself();
2143
2144   TGeoCompositeShape *sLowUpGlueBar1 = new TGeoCompositeShape(
2145                      "sUpGlueBar1:upGlueBarTr1-sRoundHole:hybHolePos1");
2146   TGeoCompositeShape *sLowAlBar1 = new TGeoCompositeShape(
2147                       "sAlBar1:alBarTr1-sRoundHole:hybHolePos1");
2148   TGeoVolume *vLowUpGlueBar1 = new TGeoVolume("vLowUpGlueBar1",
2149                                               sLowUpGlueBar1, polyhamideSDD);
2150   TGeoVolume *vLowAlBar1 = new TGeoVolume("vLowAlBar1",
2151                                           sLowAlBar1, alSDD);
2152   vLowUpGlueBar1->SetLineColor(fColorPolyhamide);
2153   vLowAlBar1->SetLineColor(fColorAl);
2154   hybrid->AddNode(vLowUpGlueBar1,1,0);
2155   hybrid->AddNode(vLowAlBar1,1,0);
2156
2157   //---
2158   //here the upedex and glue layers are both assumed to be polyimide
2159   TGeoBBox *sUpGlueBar2 = new TGeoBBox("sUpGlueBar2", fgkHybridWidth/2,
2160                                        (fgkHybGlueLowThick+fgkHybUpThick)/2,
2161                                        sideWidth2/2);
2162   TGeoBBox *sAlBar2 = new TGeoBBox("sAlBar2", fgkHybridWidth/2,
2163                                    fgkHybAlThick/2, sideWidth2/2);
2164
2165   TGeoTranslation *upGlueBarTr2 = new TGeoTranslation("upGlueBarTr2", 0,
2166                               lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
2167                                                (fgkHybridLength-sideWidth2)/2);
2168   TGeoTranslation *alBarTr2 = new TGeoTranslation("alBarTr2", 0,
2169                     lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
2170                                                (fgkHybridLength-sideWidth2)/2);
2171   upGlueBarTr2->RegisterYourself();
2172   alBarTr2->RegisterYourself();
2173
2174   TGeoCompositeShape *sLowUpGlueBar2 = new TGeoCompositeShape(
2175                      "sUpGlueBar2:upGlueBarTr2-sRoundHole:hybHolePos2");
2176   TGeoCompositeShape *sLowAlBar2 = new TGeoCompositeShape(
2177                       "sAlBar2:alBarTr2-sRoundHole:hybHolePos2");
2178   TGeoVolume *vLowUpGlueBar2 = new TGeoVolume("vLowUpGlueBar2",sLowUpGlueBar2,
2179                                               polyhamideSDD);
2180   TGeoVolume *vLowAlBar2 = new TGeoVolume("vLowAlBar2",sLowAlBar2,
2181                                           alSDD);
2182   vLowUpGlueBar2->SetLineColor(fColorPolyhamide);
2183   vLowAlBar2->SetLineColor(fColorAl);
2184   hybrid->AddNode(vLowUpGlueBar2, 1, 0);
2185   hybrid->AddNode(vLowAlBar2, 1, 0);
2186
2187   if(GetDebug(3)) { // Remove compiler warning.
2188     sAlScreenLayer->InspectShape();
2189     sUpGlueScreenLayer->InspectShape();
2190     sRoundHole->InspectShape();
2191     sUpGlueBar1->InspectShape();
2192     sUpGlueBar2->InspectShape();
2193     sAlBar1->InspectShape();
2194     sAlBar2->InspectShape();
2195   };
2196   //---
2197   //using class AliITSv11GeomCableFlat to add 2-layer segments ...
2198   Double_t piece1width = fgkHybFLlowPasX-fgkHybFLlowHolePasDX/2;
2199   AliITSv11GeomCableFlat lowFLpiece("lowFLpiece1",piece1width,
2200                                        lowFLTotalThick);
2201   lowFLpiece.SetNLayers(2);
2202   lowFLpiece.SetLayer(0, fgkHybGlueLowThick+fgkHybUpThick, polyhamideSDD,
2203                        fColorPolyhamide);
2204   lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD80p100, fColorAl);
2205   // alSDD at 80% : mostly to take into account strips of piece 3
2206
2207   Double_t x1[3] = { -fgkHybridWidth/2 + piece1width/2,
2208                      lowLayerYmin + lowFLTotalThick/2,
2209                      -fgkHybridLength/2 + sideWidth1 };
2210   Double_t x2[3] ={ x1[0], x1[1], fgkHybridLength/2 - sideWidth2 };
2211   Double_t vZ[3] = {0,0,1};
2212   lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2213   lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2214   lowFLpiece.SetInitialNode(hybrid);
2215   lowFLpiece.CreateAndInsertBoxCableSegment(1);
2216   lowFLpiece.ResetPoints();
2217
2218   Double_t piece2width = fgkHybFLlowAmbX-fgkHybFLlowPasX
2219                          -fgkHybFLlowHolePasDX/2-fgkHybFLlowHoleAmbDX/2;
2220
2221   lowFLpiece.SetWidth(piece2width);
2222   lowFLpiece.SetName("lowFLpiece2");
2223   x1[0] = piece2width/2+fgkHybFLlowPasX+fgkHybFLlowHolePasDX/2-fgkHybridWidth/2;
2224   x2[0] = x1[0];
2225   lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2226   lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2227   lowFLpiece.CreateAndInsertBoxCableSegment(1);
2228   lowFLpiece.ResetPoints();
2229
2230   Double_t piece3width = fgkHybridWidth - fgkHybFLlowAmbX
2231                          - fgkHybFLlowHoleAmbDX/2;
2232
2233   lowFLpiece.SetWidth(piece3width);
2234   lowFLpiece.SetName("lowFLpiece3");
2235   x1[0] = fgkHybridWidth/2-piece3width/2;
2236   x2[0] = x1[0];
2237   lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2238   lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2239   lowFLpiece.CreateAndInsertBoxCableSegment(1);
2240
2241   Double_t zChips[4] = {fgkHybFLlowChipZ1,fgkHybFLlowChipZ2,
2242                         fgkHybFLlowChipZ3,fgkHybFLlowChipZ4};
2243   Double_t vX[3] = {1,0,0};
2244   for (Int_t i=0; i<3; i++) {
2245     char ch[20];
2246     snprintf(ch, 20, "lowFLpieceA%i", i+4);
2247     lowFLpiece.SetName(ch);
2248     lowFLpiece.SetWidth(zChips[i+1]-zChips[i]-fgkHybFLlowHoleDZ);
2249
2250     lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD, fColorAl);
2251     x1[0] = -fgkHybridWidth/2 + piece1width;
2252     x2[0] = x1[0] + fgkHybFLlowHolePasDX;
2253     Double_t zPiece = (zChips[i+1]+zChips[i])/2 - fgkHybridLength/2;
2254     x1[2] = zPiece; x2[2] = zPiece;
2255     lowFLpiece.AddCheckPoint( hybrid, 0, x2, vX );
2256     lowFLpiece.AddCheckPoint( hybrid, 1, x1, vX );
2257     lowFLpiece.CreateAndInsertBoxCableSegment(1,90);
2258     lowFLpiece.ResetPoints();
2259
2260     snprintf(ch, 20, "lowFLpieceB%i", i+4);
2261     lowFLpiece.SetName(ch);
2262     x1[0] = fgkHybridWidth/2 - piece3width;
2263     x2[0] = x1[0] - fgkHybFLlowHoleAmbDX;
2264     lowFLpiece.AddCheckPoint( hybrid, 0, x1, vX );
2265     lowFLpiece.AddCheckPoint( hybrid, 1, x2, vX );
2266     lowFLpiece.CreateAndInsertBoxCableSegment(1,90);
2267   };
2268
2269   //**************************************************** chips+CC:
2270   AliITSv11GeomCableFlat chip("", fgkHybChipsDZ, chipsCCTotThick);
2271   chip.SetInitialNode(hybrid);
2272   chip.SetNLayers(5);
2273   chip.SetLayer(0, fgkHybUnderNiThick, niSDD, 2);
2274   chip.SetLayer(1, fgkHybGlueAgThick, glueAG, 4);
2275   chip.SetLayer(2, fgkHybChipThick, siliconSDD, fColorSilicon);
2276   chip.SetLayer(3, fgkHybUpCCThick+fgkHybUpCCThick, polyhamideSDD,
2277                 fColorPolyhamide);
2278   chip.SetLayer(4, fgkHybAlCCThick+fgkHybAlCCThick, alSDD80p100, fColorAl);
2279   // Here the tho CC (low+up) are merged
2280   // In fact, the last layer has a smaller surface of Al -> I put 80%
2281
2282   x1[1] = lowLayerYmin + chipsCCTotThick/2;
2283   x2[1] = x1[1];
2284   char ch[20];
2285
2286   for (Int_t i=0; i<4; i++) {
2287     snprintf(ch, 20, "pascalCC%i", i);
2288     chip.SetName(ch);
2289     x1[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
2290     x2[0] = x1[0] + fgkHybPascalDX;
2291     x1[2] =  zChips[i] - fgkHybridLength/2;
2292     x2[2] = x1[2];
2293     chip.AddCheckPoint( hybrid, 0, x1, vX );
2294     chip.AddCheckPoint( hybrid, 1, x2, vX );
2295     chip.CreateAndInsertBoxCableSegment(1,-90);
2296     chip.ResetPoints();
2297
2298     snprintf(ch, 20, "ambraCC%i", i);
2299     chip.SetName(ch);
2300     x1[0] = fgkHybFLlowAmbX - fgkHybridWidth/2 - fgkHybAmbraDX/2;
2301     x2[0] = x1[0] + fgkHybAmbraDX;
2302     chip.AddCheckPoint( hybrid, 0, x1, vX );
2303     chip.AddCheckPoint( hybrid, 1, x2, vX );
2304     chip.CreateAndInsertBoxCableSegment(1,-90);
2305     chip.ResetPoints();
2306   };
2307
2308   //**************************************************** CC outside chips:
2309   // I don't think there is a second aluminium layer here ...
2310   for (Int_t i = 0; i<4; i++) {
2311     snprintf(ch, 20, "ccLayerA%i", i);
2312
2313     AliITSv11GeomCableFlat ccLayer1(ch, 6.6*fgkmm, ccUpLayerTotThick);
2314     ccLayer1.SetInitialNode(hybrid);
2315     ccLayer1.SetNLayers(2);
2316     ccLayer1.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
2317     ccLayer1.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
2318     // Al at ~50%
2319
2320     x1[0] = -fgkHybridWidth/2;
2321     x2[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
2322     x1[1] = lowLayerYmin + fgkHybUnderNiThick + fgkHybGlueAgThick
2323             + fgkHybChipThick + ccUpLayerTotThick/2;
2324     x2[1] = x1[1];
2325     x1[2] = zChips[i] - fgkHybridLength/2;
2326     x2[2] = x1[2];
2327     ccLayer1.AddCheckPoint( hybrid, 0, x1, vX );
2328     ccLayer1.AddCheckPoint( hybrid, 1, x2, vX );
2329     ccLayer1.CreateAndInsertBoxCableSegment(1,-90);
2330
2331     snprintf(ch, 20, "ccLayerB%i", i);
2332     AliITSv11GeomCableFlat ccLayer2(ch, fgkHybChipsDZ, ccUpLayerTotThick);
2333     ccLayer2.SetInitialNode(hybrid);
2334     ccLayer2.SetNLayers(2);
2335     ccLayer2.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
2336     ccLayer2.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
2337      // Al at ~50%
2338
2339     x1[0] = -fgkHybridWidth/2 + fgkHybFLlowPasX + fgkHybPascalDX/2;
2340     x2[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX - fgkHybAmbraDX/2;
2341     ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
2342     ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
2343     ccLayer2.CreateAndInsertBoxCableSegment(1,-90);
2344     ccLayer2.ResetPoints();
2345     snprintf(ch, 20, "ccLayerC%i", i);
2346     ccLayer2.SetName(ch);
2347     x1[0] =  -fgkHybridWidth/2 + fgkHybFLlowAmbX + fgkHybAmbraDX/2;
2348     x2[0] = fgkHybridWidth/2 - fgkHybFLUpperWidth + 3*fgkmm;
2349     x1[1] = lowLayerYmin + lowFLTotalThick + flUpThick + fgkHybAlThick
2350              + ccUpLayerTotThick/2;
2351     x2[1] = x1[1];
2352
2353     ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
2354     ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
2355     ccLayer2.CreateAndInsertBoxCableSegment(1,-90);
2356
2357   //**************************************************** CC to sensors:
2358   // (alas, we cannot use GeomCableFlat here because section is not constant)
2359     Double_t xcc[6],ycc[6];
2360     xcc[0] = -0.5*ccLayer1.GetWidth();
2361     ycc[0] =  0;
2362     xcc[1] =  0.5*ccLayer1.GetWidth();
2363     ycc[1] =  0;
2364     xcc[2] = xcc[1];
2365     ycc[2] = -fgkHybCC2SensorLen;
2366     xcc[3] = xcc[2] - fgkHybCC2SensorWid;
2367     ycc[3] = ycc[2];
2368     xcc[4] = xcc[3];
2369     ycc[4] = 0.8*ycc[3];
2370     xcc[5] = xcc[0];
2371     ycc[5] = 0.2*ycc[3];
2372
2373     TGeoXtru* ccToSensPoliSh = new TGeoXtru(2);
2374     ccToSensPoliSh->DefinePolygon(6, xcc, ycc);
2375     ccToSensPoliSh->DefineSection(0, 0.);
2376     ccToSensPoliSh->DefineSection(1, ccLayer1.GetThickness());
2377
2378     snprintf(ch, 20, "ccToSens%i", i);
2379     TGeoVolume* ccToSensPoliVol = new TGeoVolume(ch, ccToSensPoliSh, polyhamideSDD);
2380     ccToSensPoliVol->SetLineColor(fColorPolyhamide);
2381
2382     TGeoXtru* ccToSensAlSh = new TGeoXtru(2);
2383     ccToSensAlSh->DefinePolygon(6, xcc, ycc);
2384     ccToSensAlSh->DefineSection(0, 0.);
2385     ccToSensAlSh->DefineSection(1, fgkHybAlCCThick);
2386
2387     snprintf(ch, 20, "ccToSensAl%i", i);
2388     TGeoVolume* ccToSensAlVol = new TGeoVolume(ch, ccToSensAlSh, alSDD50p100);
2389     ccToSensAlVol->SetLineColor(fColorAl);
2390
2391     ccToSensPoliVol->AddNode(ccToSensAlVol, 1, 0);
2392
2393     Double_t coord[3];
2394     ccLayer1.GetPoint(0,coord);
2395     hybrid->AddNode(ccToSensPoliVol, i+1,
2396                     new TGeoCombiTrans(coord[0], coord[1], coord[2],
2397                         new TGeoRotation("",-90-fgkHybCC2SensorAng, 90, 90)));
2398   };
2399
2400   //**************************************************** FL UP:
2401   // (last Al layer will be a special triangular shape)
2402   TGeoBBox *sFLupPolyhamide = new TGeoBBox("sFLupPolyhamide",
2403                               fgkHybFLUpperWidth/2, flUpThick/2,
2404                               fgkHybFLUpperLength/2);
2405   TGeoVolume *vFLupPolyhamide = new TGeoVolume("vFLupPolyhamide",
2406                                     sFLupPolyhamide, polyhamideSDD);
2407   vFLupPolyhamide->SetLineColor(fColorPolyhamide);
2408   TGeoTranslation *trFLupPolyhamide =
2409     new TGeoTranslation(fgkHybridWidth/2-fgkHybFLUpperWidth/2,
2410                         lowLayerYmin+lowFLTotalThick+flUpThick/2,0);
2411
2412   hybrid->AddNode(vFLupPolyhamide, 1, trFLupPolyhamide);
2413
2414   TGeoArb8 *aluStrip = new TGeoArb8(fgkHybAlThick/2);
2415   aluStrip->SetVertex( 0,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2416   aluStrip->SetVertex( 1, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2417   aluStrip->SetVertex( 2, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
2418   aluStrip->SetVertex( 3,-fgkHybFLUpperAlDZ/2, 0);
2419   aluStrip->SetVertex( 4,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2420   aluStrip->SetVertex( 5, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2421   aluStrip->SetVertex( 6, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
2422   aluStrip->SetVertex( 7,-fgkHybFLUpperAlDZ/2, 0);
2423   TGeoVolume *vAluStrip = new TGeoVolume("vAluStrip",aluStrip, alSDD50p100);
2424   // Al at ~50%
2425
2426   vAluStrip->SetLineColor(fColorAl);
2427   //TGeoRotation rotAluStrip("rotAluStrip",0, -90, 90);
2428   TGeoRotation *rotAluStrip = new TGeoRotation("rotAluStrip",0, -90, 90);
2429
2430   Double_t yRotAluStrip = lowLayerYmin+lowFLTotalThick
2431                           +flUpThick+fgkHybAlThick/2;
2432   TGeoCombiTrans *aluStripTr1 = new TGeoCombiTrans(
2433                                     fgkHybridWidth/2,yRotAluStrip,
2434                     fgkHybridLength/2-fgkHybFLlowChipZ1+1*fgkmm, rotAluStrip);
2435   TGeoCombiTrans *aluStripTr2 = new TGeoCombiTrans(*aluStripTr1);
2436   AddTranslationToCombiTrans(aluStripTr2,0,0,
2437                              fgkHybFLlowChipZ1-fgkHybFLlowChipZ2);
2438   TGeoCombiTrans *aluStripTr3 = new TGeoCombiTrans(*aluStripTr2);
2439   AddTranslationToCombiTrans(aluStripTr3,0,0,
2440                              fgkHybFLlowChipZ2-fgkHybFLlowChipZ3);
2441   TGeoCombiTrans *aluStripTr4 = new TGeoCombiTrans(*aluStripTr3);
2442   AddTranslationToCombiTrans(aluStripTr4,0,0,
2443                              fgkHybFLlowChipZ3-fgkHybFLlowChipZ4);
2444
2445   hybrid->AddNode(vAluStrip, 1, aluStripTr1);
2446   hybrid->AddNode(vAluStrip, 2, aluStripTr2);
2447   hybrid->AddNode(vAluStrip, 3, aluStripTr3);
2448   hybrid->AddNode(vAluStrip, 4, aluStripTr4);
2449   //**************************************************** SMD:
2450   TGeoBBox *hybSMD = new TGeoBBox("ITSsddSMDshape",
2451                                   fgkHybSMDmiddleL/2+fgkHybSMDendL,
2452                                   fgkHybSMDheight/2,fgkHybSMDendW/2);
2453   TGeoVolume *vHybSMD = new TGeoVolume("ITSsddSMD",hybSMD,airSDD);
2454
2455   TGeoBBox *hybSMDmiddle = new TGeoBBox("ITSsddSMDmiddleShape",
2456                                fgkHybSMDmiddleL/2,fgkHybSMDheight/2,
2457                                         fgkHybSMDmiddleW/2);
2458   TGeoVolume *vHybSMDmiddle = new TGeoVolume("ITSsddSMDmiddle",
2459                                             hybSMDmiddle,medSMD);
2460   vHybSMDmiddle->SetLineColor(fColorSMD);
2461   TGeoBBox *hybSMDend = new TGeoBBox("ITSsddSMDendShape",
2462                             fgkHybSMDendL/2,fgkHybSMDheight/2,fgkHybSMDendW/2);
2463   TGeoVolume *vHybSMDend = new TGeoVolume("ITSsddSMDend",
2464                                           hybSMDend,medSMDweld);
2465   vHybSMDend->SetLineColor(fColorSMDweld);
2466   TGeoTranslation *vHybSMDendTr1 = new TGeoTranslation("",
2467                                        (fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
2468   TGeoTranslation *vHybSMDendTr2 = new TGeoTranslation("",
2469                                        -(fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
2470   vHybSMD->AddNode(vHybSMDmiddle,1,0);
2471   vHybSMD->AddNode(vHybSMDend,1,vHybSMDendTr1);
2472   vHybSMD->AddNode(vHybSMDend,2,vHybSMDendTr2);
2473   for (Int_t i=0; i<fgkNHybSMD; i++) {
2474     TGeoTranslation *vHybSMDtr = new TGeoTranslation("",
2475                                  -fgkHybridWidth/2+fgkHybSMDposX[i],
2476                                  lowLayerYmin+lowFLTotalThick+fgkHybSMDheight/2,
2477                                  -fgkHybridLength/2+fgkHybSMDposZ[i]);
2478     hybrid->AddNode(vHybSMD, i+1, vHybSMDtr);
2479   };
2480
2481   if (iLRSide == 0) {
2482   };
2483
2484   if(GetDebug(1)) hybrid->CheckOverlaps(0.01);
2485   hybrid->SetVisibility(kFALSE);
2486   return hybrid;
2487 }
2488
2489 //________________________________________________________________________
2490 TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
2491   //
2492   // Return a TGeoVolume* containing a segment of a ladder.
2493   //
2494
2495   TGeoMedium *phynoxSDD       = GetMedium("INOX$");
2496   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
2497   TGeoMedium *airSDD          = GetMedium("SDD AIR$");
2498   TGeoMedium *alSDD           = GetMedium("AL$");
2499
2500   Double_t tDY = fgkLadderSegBoxDH/2; //space left on top of the ladder
2501   Double_t segmentLength = fgkSegmentLength;
2502   Double_t spaceBetweenCables = 500*fgkmicron;
2503
2504   //*****************************************
2505   // Set parameters according to (iLay,iSeg):
2506   //*****************************************
2507   Int_t nDetectors          = fgkLay3Ndet;
2508   Double_t coolPipeSuppH    = fgkLay3CoolPipeSuppH;
2509   Double_t sensorCenterZPos = fLay3sensorZPos[iSeg]-
2510                               (fgkSegmentLength*fgkLay3Ndet/2. -
2511                                fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
2512  // sensorCenterZPos = z in segment local coord syst.
2513
2514   AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
2515   AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
2516
2517   if (iLay==3) {
2518   } else if (iLay==4) {
2519     nDetectors = fgkLay4Ndet;
2520     coolPipeSuppH = fgkLay4CoolPipeSuppH;
2521     sensorCenterZPos = fLay4sensorZPos[iSeg]-
2522                        (fgkSegmentLength*fgkLay4Ndet/2. -
2523                         fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
2524     digitCableA = fDigitCableLay4A;
2525     digitCableB = fDigitCableLay4B;
2526   } else
2527     printf("AliITSv11GeometrySDD::CreateLadderSegment Wrong layer index !");
2528
2529
2530   Double_t cableSideSign = -1;
2531   if (iSeg<nDetectors/2) cableSideSign = 1;
2532   Double_t spaceForCables = spaceBetweenCables*
2533            (nDetectors-TMath::Abs(nDetectors-2*iSeg-1)-1)/2
2534            +0.1*fgkmicron;
2535   // gives [0-1-2-2-1-0]*spaceBetweenCables
2536   // or  [0-1-2-3-3-2-1-0]*spaceBetweenCables
2537   Int_t iUpdateCableMin;
2538   Int_t iUpdateCableMax;
2539   if (cableSideSign==-1) {
2540     iUpdateCableMin = nDetectors/2;
2541     iUpdateCableMax = iSeg-1;
2542   } else {
2543     iUpdateCableMin = iSeg+1;
2544     iUpdateCableMax = nDetectors/2-1;
2545   };
2546
2547   if(GetDebug(1)){
2548     cout << "Segment ("<< iLay <<',' << iSeg
2549          << ") : sensor z shift in local segment coord.="
2550          << sensorCenterZPos << endl;
2551   };
2552
2553   //****************************
2554   // The segment volume
2555   //****************************
2556
2557   // Use of TGeoVolumeAssembly increases the calculation time of overlaps and very
2558   // likely slows down the transport of particles through the geometry
2559
2560   //TGeoVolumeAssembly *virtualSeg = new TGeoVolumeAssembly("ITSsddSegment");
2561
2562 //   TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox",
2563 //                                fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
2564 //                                fgkLadderHeight/2+fgkLadderSegBoxDH/2,
2565 //                                segmentLength/2);
2566   // A shaped Xtru instead of a simple BBox to avoid overlaps and extrusions
2567   TGeoXtru *segBox = new TGeoXtru(2);
2568   segBox->SetName("ITSsddSegBox");
2569
2570   Double_t xseg[8],yseg[8];
2571   xseg[0] = -(fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW);
2572   yseg[0] =  fgkLadderHeight/2+fgkLadderSegBoxDH/2;
2573   xseg[1] =  xseg[0];
2574   yseg[1] = -yseg[0];
2575   xseg[2] = -xseg[1];
2576   yseg[2] =  yseg[1];
2577   xseg[3] =  xseg[2];
2578   yseg[3] =  yseg[0];
2579   xseg[4] =  0.35*xseg[3];
2580   yseg[4] =  yseg[3];
2581   xseg[5] =  xseg[4];
2582   yseg[5] =  yseg[4] + fgkLadderSegBoxDHCorr;
2583   xseg[6] = -xseg[4];
2584   yseg[6] =  yseg[5];
2585   xseg[7] =  xseg[6];
2586   yseg[7] =  yseg[0];
2587
2588   segBox->DefinePolygon(8, xseg, yseg);
2589   segBox->DefineSection(0,-segmentLength/2);
2590   segBox->DefineSection(1, segmentLength/2);
2591
2592   TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment",
2593                                           segBox, airSDD);
2594   virtualSeg->SetVisibility(kFALSE);
2595
2596   //******************************
2597   // Carbon fiber structure :
2598   //******************************
2599
2600    virtualSeg->AddNode(fLaddSegCommonVol[0], 1, fLaddSegCommonTr[0]);
2601   Int_t volumeIndex = 1;
2602   for (Int_t i = 1; i<fgkNladdSegCommonVol;i++ ) {
2603     if (fLaddSegCommonVol[i]==fLaddSegCommonVol[i-1])
2604       volumeIndex++;
2605     else
2606       volumeIndex = 1;
2607     virtualSeg->AddNode(fLaddSegCommonVol[i], volumeIndex,
2608                  fLaddSegCommonTr[i]);
2609   };
2610
2611   //**********************************
2612   // Pine support of the sensors :
2613   //**********************************
2614   TGeoRotation *rotPS1 = new TGeoRotation("",0,-90,90);
2615   TGeoRotation *rotPS2 = new TGeoRotation("",0,-90,-90);
2616
2617   // The use of the following constructor type allow to use rotPS1 and rotPS2
2618   // (and not copy them) therefore we gain some memory
2619   TGeoCombiTrans *transPS1 = new TGeoCombiTrans( fgkPinDYOnSensor,
2620                                 - fgkLadderHeight/2.-tDY
2621                                 + fgkPinSuppHeight/2.,
2622                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2623
2624   TGeoCombiTrans *transPS2 = new TGeoCombiTrans( fgkPinDYOnSensor,
2625                                 - fgkLadderHeight/2.-tDY
2626                                 + fgkPinSuppHeight/2.,
2627                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2628   AddTranslationToCombiTrans(transPS2, 0, 0, fgkPinPinDDXOnSensor);
2629
2630   TGeoCombiTrans *transPS3 = new TGeoCombiTrans( fgkPinDYOnSensor,
2631                                 - fgkLadderHeight/2.-tDY
2632                                 + fgkPinSuppHeight/2.,
2633                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2634   AddTranslationToCombiTrans(transPS3, 0, 0, -2*fgkPinDXminOnSensor);
2635
2636   TGeoCombiTrans *transPS4 = new TGeoCombiTrans( fgkPinDYOnSensor,
2637                                 - fgkLadderHeight/2.-tDY
2638                                 + fgkPinSuppHeight/2.,
2639                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2640   AddTranslationToCombiTrans(transPS4, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2641
2642   TGeoCombiTrans *transPS5 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2643                                  - fgkLadderHeight/2. - tDY
2644                                  + fgkPinSuppHeight/2.,
2645                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2646
2647   TGeoCombiTrans *transPS6 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2648                                  - fgkLadderHeight/2. - tDY
2649                                  + fgkPinSuppHeight/2.,
2650                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2651   AddTranslationToCombiTrans(transPS6, 0, 0, fgkPinPinDDXOnSensor);
2652
2653   TGeoCombiTrans *transPS7 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2654                                  - fgkLadderHeight/2. - tDY
2655                                  + fgkPinSuppHeight/2.,
2656                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2657   AddTranslationToCombiTrans(transPS7, 0, 0, -2*fgkPinDXminOnSensor);
2658
2659   TGeoCombiTrans *transPS8 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2660                                  - fgkLadderHeight/2. - tDY
2661                                  + fgkPinSuppHeight/2.,
2662                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2663   AddTranslationToCombiTrans(transPS8, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2664
2665   virtualSeg->AddNode(fPinSupport, 1, transPS1);
2666   virtualSeg->AddNode(fPinSupport, 2, transPS2);
2667   virtualSeg->AddNode(fPinSupport, 3, transPS3);
2668   virtualSeg->AddNode(fPinSupport, 4, transPS4);
2669   virtualSeg->AddNode(fPinSupport, 5, transPS5);
2670   virtualSeg->AddNode(fPinSupport, 6, transPS6);
2671   virtualSeg->AddNode(fPinSupport, 7, transPS7);
2672   virtualSeg->AddNode(fPinSupport, 8, transPS8);
2673
2674   TGeoMedium *pinMed   = GetMedium("RYTON$");
2675   Double_t fgkPinHeight = 4.5*fgkmm;
2676   TGeoTube *pineS = new TGeoTube("ITSsddPin",0,fgkPinR,
2677                                 fgkPinHeight/2.);
2678   TGeoVolume *pineV = new TGeoVolume("ITSsddPinVol", pineS, pinMed);
2679
2680   TGeoCombiTrans *transPS2b = new TGeoCombiTrans( fgkPinDYOnSensor,
2681                                 - fgkLadderHeight/2.-tDY
2682                                 + fgkPinHeight/2.,
2683                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2684   AddTranslationToCombiTrans(transPS2b, 0, 0, fgkPinPinDDXOnSensor);
2685   virtualSeg->AddNode(pineV, 1, transPS2b);
2686
2687   TGeoCombiTrans *transPS6b = new TGeoCombiTrans( -fgkPinDYOnSensor,
2688                                  - fgkLadderHeight/2. - tDY
2689                                  + fgkPinHeight/2.,
2690                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2691   AddTranslationToCombiTrans(transPS6b, 0, 0, fgkPinPinDDXOnSensor);
2692   virtualSeg->AddNode(pineV, 2, transPS6b);
2693
2694
2695   TGeoCombiTrans *transPS4b = new TGeoCombiTrans( fgkPinDYOnSensor,
2696                                 - fgkLadderHeight/2.-tDY
2697                                 + fgkPinHeight/2.,
2698                                 sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2699   AddTranslationToCombiTrans(transPS4b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2700   virtualSeg->AddNode(pineV, 3, transPS4b);
2701
2702   TGeoCombiTrans *transPS8b = new TGeoCombiTrans( -fgkPinDYOnSensor,
2703                                  - fgkLadderHeight/2. - tDY
2704                                  + fgkPinHeight/2.,
2705                                  sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2706   AddTranslationToCombiTrans(transPS8b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2707   virtualSeg->AddNode(pineV, 4, transPS8b);
2708
2709
2710   //******************************
2711   // Cooling pipe supports :
2712   //******************************
2713   Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
2714   Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
2715   Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
2716                                fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
2717
2718   Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
2719                            (triangleHeight+triangleCPaxeDist/
2720                             TMath::Sin(halfTheta)-coolPipeSuppH);
2721   if (fAddCoolingSyst) {
2722   TGeoRotation *rotCPS2 = new TGeoRotation("", -halfTheta*TMath::RadToDeg(), -90,  90);
2723   TGeoRotation *rotCPS1 = new TGeoRotation("",  halfTheta*TMath::RadToDeg(), -90, -90);
2724   TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
2725                                   -fgkLadderHeight/2. - tDY
2726                                   +coolPipeSuppH+fgkLadderBeamRadius,
2727                                   -segmentLength/2., rotCPS1);
2728
2729   TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(coolPipeSuppL,
2730                                   -fgkLadderHeight/2. - tDY
2731                                   +coolPipeSuppH+fgkLadderBeamRadius,
2732                                   -segmentLength/2., rotCPS1);
2733   AddTranslationToCombiTrans(transCPS3, 0, 0, segmentLength);
2734
2735   TGeoCombiTrans *transCPS2 = new TGeoCombiTrans(-coolPipeSuppL,
2736                                   -fgkLadderHeight/2.- tDY
2737                                   +coolPipeSuppH+fgkLadderBeamRadius,
2738                                   segmentLength/2., rotCPS2);
2739
2740   TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
2741                                   -fgkLadderHeight/2.- tDY
2742                                   +coolPipeSuppH+fgkLadderBeamRadius,
2743                                   segmentLength/2., rotCPS2);
2744   AddTranslationToCombiTrans(transCPS4, 0, 0, -segmentLength);
2745
2746   virtualSeg->AddNode(fCoolPipeSupportL, 1, transCPS1);
2747   virtualSeg->AddNode(fCoolPipeSupportL, 2, transCPS2);
2748   virtualSeg->AddNode(fCoolPipeSupportR, 1, transCPS3);
2749   virtualSeg->AddNode(fCoolPipeSupportR, 2, transCPS4);
2750   };
2751
2752   //************************
2753   // Cooling pipes :
2754   //************************
2755   TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
2756                                  -fgkLadderHeight/2. - tDY +
2757                                  fgkLadderBeamRadius+coolPipeSuppH, 0);
2758   TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
2759                                  -fgkLadderHeight/2.- tDY +
2760                                   fgkLadderBeamRadius+coolPipeSuppH, 0);
2761
2762   if (fAddCoolingSyst) {
2763     TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
2764                                                fgkCoolPipeOuterDiam/2,
2765                                                segmentLength/2);
2766     TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
2767                                           segmentLength/2);
2768
2769     TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipe",
2770                                              coolingPipeShape, phynoxSDD );
2771     coolingPipe->SetLineColor(fColorPhynox);
2772     TGeoVolume *cooler = new  TGeoVolume("ITSsddCoolingLiquid",coolerShape,
2773                                          coolerMediumSDD );
2774
2775
2776     virtualSeg->AddNode(coolingPipe, 1, pipeTr1);
2777     virtualSeg->AddNode(coolingPipe, 2, pipeTr2);
2778     if (fCoolingOn) {
2779       virtualSeg->AddNode(cooler, 1, pipeTr1);
2780       virtualSeg->AddNode(cooler, 2, pipeTr2);
2781     };
2782   };
2783
2784   //**********************************
2785   // Bases of hybrid thermal bridges
2786   //**********************************
2787   Double_t shiftHyb = 1.05; // shift between thermal Bridge base and thermal bridge
2788                            // approx !!! not clear on 0752/14-A
2789   if (fAddCoolingSyst) {
2790   TGeoRotation rotHybrid1("", 0,   0, -90 - fgkHybridAngle);
2791   TGeoRotation rotHybrid2("", 0 ,180,  90 - fgkHybridAngle);
2792   TGeoCombiTrans *baseTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid1);
2793   TGeoCombiTrans *baseTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid2);
2794
2795   virtualSeg->AddNode(fBaseThermalBridge, 1, baseTr1);
2796   virtualSeg->AddNode(fBaseThermalBridge, 2, baseTr2);
2797   };
2798
2799   //*************************
2800   // the 2 hybrids :
2801   //*************************
2802   Double_t hybDy = ((TGeoBBox*)fHybrid->GetShape())->GetDY();
2803   Double_t distAxeToHybridCenter = fgkBTBaxisAtoBase+hybDy;
2804
2805   Double_t hybrVolX = ( distAxeToHybridCenter*CosD(fgkHybridAngle)
2806                          - shiftHyb*SinD(fgkHybridAngle) );
2807   Double_t hybrVolY = ( distAxeToHybridCenter*SinD(fgkHybridAngle)
2808                          + shiftHyb*CosD(fgkHybridAngle) );
2809   if (fAddHybrids) {
2810     TGeoRotation rotHybrid3("", 0,   0,  90. - fgkHybridAngle);
2811     TGeoRotation rotHybrid4("", 0 ,180, -90. - fgkHybridAngle);
2812     TGeoCombiTrans *hybTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid3);
2813     TGeoCombiTrans *hybTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid4);
2814     AddTranslationToCombiTrans( hybTr1, -hybrVolX, hybrVolY, 0);
2815     AddTranslationToCombiTrans( hybTr2,  hybrVolX, hybrVolY, 0);
2816
2817     virtualSeg->AddNode(fHybrid, 1, hybTr1);
2818     virtualSeg->AddNode(fHybrid, 2, hybTr2);
2819   };
2820
2821   //***********
2822   // cables
2823   //***********
2824   if (fAddCables) {
2825   // Starting from this segment
2826   Double_t hybDz = ((TGeoXtru*)fHybrid->GetShape())->GetZ(1);
2827   Double_t hybDx = ((TGeoXtru*)fHybrid->GetShape())->GetX(1);
2828   Double_t posDigitCableAlongHyb = shiftHyb+ hybDx
2829                                    - digitCableA->GetWidth()/2;
2830   Double_t distAxeToDigitCableCenter = distAxeToHybridCenter+hybDy
2831                                        - digitCableA->GetThickness()/2;
2832
2833   Double_t digitCableX = ( coolPipeSuppL
2834                            + distAxeToDigitCableCenter*CosD(fgkHybridAngle)
2835                            - posDigitCableAlongHyb*SinD(fgkHybridAngle) );
2836   Double_t digitCableY = ( - fgkLadderHeight/2.-TMath::Abs(tDY)
2837                            + fgkLadderBeamRadius+coolPipeSuppH
2838                            + distAxeToDigitCableCenter*SinD(fgkHybridAngle)
2839                            + posDigitCableAlongHyb*CosD(fgkHybridAngle) );
2840
2841
2842   Double_t digitCableCenterA0[3]={ -cableSideSign*digitCableX,
2843                                    digitCableY, cableSideSign*hybDz };
2844   Double_t digitCableCenterA1[3] = {
2845            -cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
2846            digitCableY+spaceForCables*SinD(fgkHybridAngle),
2847            cableSideSign*segmentLength/2 };
2848
2849   Double_t digitCableCenterB0[3]={ cableSideSign*digitCableX,
2850                                    digitCableY,cableSideSign*hybDz};
2851   Double_t digitCableCenterB1[3]={
2852            cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
2853            digitCableY+spaceForCables*SinD(fgkHybridAngle),
2854            cableSideSign*segmentLength/2 };
2855
2856   Double_t vZ[3] = {0,0,1};
2857   digitCableA[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterA0, vZ);
2858   digitCableA[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterA1, vZ);
2859   digitCableB[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterB0, vZ);
2860   digitCableB[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterB1, vZ);
2861
2862   // Updating the other cables
2863   for (Int_t iCable=iUpdateCableMin; iCable<=iUpdateCableMax; iCable++) {
2864
2865     Int_t iPoint = TMath::Abs(iCable-iSeg)+1;
2866     Double_t coord[3];
2867     digitCableA[iCable].GetPoint( 1, coord);
2868     digitCableA[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
2869     digitCableB[iCable].GetPoint( 1, coord);
2870     digitCableB[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
2871   };
2872
2873   // Now the small Al foil on the same hybrid side
2874   Double_t xfoil[5],yfoil[5];
2875   hybDx *= 0.95;
2876   xfoil[0] = -fgkHybridAlFoilWide/2;
2877   yfoil[0] =  hybDx;
2878   xfoil[1] =  fgkHybridAlFoilWide/2;
2879   yfoil[1] =  yfoil[0];
2880   xfoil[2] =  xfoil[1];
2881   yfoil[2] = -hybDx + (fgkHybridAlFoilWide - fgkHybridAlFoilSide);
2882   xfoil[3] =  xfoil[0] + fgkHybridAlFoilSide;
2883   yfoil[3] = -hybDx;
2884   xfoil[4] =  xfoil[0];
2885   yfoil[4] =  yfoil[3];
2886
2887   TGeoXtru* alFoilSh = new TGeoXtru(2);
2888   alFoilSh->DefinePolygon(5, xfoil, yfoil);
2889   alFoilSh->DefineSection(0,-fgkHybridAlFoilThick/2);
2890   alFoilSh->DefineSection(1, fgkHybridAlFoilThick/2);
2891
2892   TGeoVolume* alFoilVol = new TGeoVolume("ITSsddAlFoilHybSide", alFoilSh, alSDD);
2893   alFoilVol->SetLineColor(fColorAl);
2894
2895   Double_t zFoilTrans = cableSideSign*(hybDz + alFoilSh->GetX(1));
2896   TGeoRotation rotFoil3;
2897   TGeoRotation rotFoil4;
2898   if (cableSideSign > 0) {
2899     rotFoil3 = TGeoRotation("", 90-fgkHybridAngle, -90, -90);
2900     rotFoil4 = TGeoRotation("",-90+fgkHybridAngle,  90,  90);
2901   } else {
2902     rotFoil3 = TGeoRotation("", 90-fgkHybridAngle,  90, -90);
2903     rotFoil4 = TGeoRotation("",-90+fgkHybridAngle, -90,  90);
2904   }
2905   TGeoCombiTrans *foiTr1 = new TGeoCombiTrans(*pipeTr2, rotFoil3);
2906   TGeoCombiTrans *foiTr2 = new TGeoCombiTrans(*pipeTr1, rotFoil4);
2907   AddTranslationToCombiTrans( foiTr1, -hybrVolX, hybrVolY, zFoilTrans);
2908   AddTranslationToCombiTrans( foiTr2,  hybrVolX, hybrVolY, zFoilTrans);
2909
2910   virtualSeg->AddNode(alFoilVol, 1, foiTr1);
2911   virtualSeg->AddNode(alFoilVol, 2, foiTr2);
2912   };
2913
2914   //**********************************
2915   if(GetDebug(1)) virtualSeg->CheckOverlaps(0.01);
2916   return virtualSeg;
2917 }
2918
2919
2920 //________________________________________________________________________
2921 TGeoVolume* AliITSv11GeometrySDD::CreatePinSupport() {
2922 //
2923 // Create a pine support and its pine
2924 // axis of rotation is the cone axis, center in its middle
2925 //
2926     TGeoMedium *rytonSDD = GetMedium("RYTON$");
2927
2928     TGeoCone *cone = new TGeoCone("ITSsddPinSuppCone",fgkPinSuppHeight/2.,
2929                                   0,fgkPinSuppRmax,0,fgkPinSuppRmax-
2930                                   fgkPinSuppHeight*TanD(fgkPinSuppConeAngle) );
2931     TGeoBBox *tong = new TGeoBBox("ITSsddPinSuppTong",fgkPinSuppRmax,
2932                                   fgkPinSuppLength/2.,fgkPinSuppThickness/2.);
2933     TGeoTube *hole = new TGeoTube("ITSsddPinSuppHole",0,fgkPinR,
2934                                   fgkPinSuppHeight/2.+0.00001);
2935     // 0.00001 is for seing the actual hole (avoid viewer artefact)
2936
2937     if(GetDebug(3)){// Remove compiler warning.
2938         cone->InspectShape();
2939         tong->InspectShape();
2940         hole->InspectShape();
2941     };
2942
2943     TGeoTranslation *tongTrans = new TGeoTranslation("ITSsddPinSuppTongTr",0,
2944                    fgkPinSuppLength/2.,-fgkPinSuppHeight/2.+fgkPinSuppThickness/2.);
2945     tongTrans->RegisterYourself();
2946     TGeoCompositeShape *pinSupportShape = new TGeoCompositeShape(
2947                "ITSsddPinSupportShape","(ITSsddPinSuppCone+"
2948                "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole");
2949
2950     TGeoVolume *pinSupport = new TGeoVolume("ITSsddPinSupport", pinSupportShape,
2951                                             rytonSDD);
2952     pinSupport->SetLineColor(fColorRyton);
2953
2954     return pinSupport;
2955 }
2956
2957
2958 //________________________________________________________________________
2959 TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() {
2960 //
2961 // Create half of the cooling pipe support (ALR-0752/3)
2962 //
2963
2964   Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
2965
2966   TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
2967   side1->SetName("ITSsddCPSside1");
2968   side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
2969   side1->SetVertex( 1, 0,  fgkCoolPipeSuppWidthExt/2.);
2970   side1->SetVertex( 2, fgkCoolPipeSuppMaxLength/2.-diffX,
2971                        fgkCoolPipeSuppWidthExt/2.);
2972   side1->SetVertex( 3, fgkCoolPipeSuppMaxLength/2.-diffX,
2973                        -fgkCoolPipeSuppWidthExt/2.);
2974   side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
2975   side1->SetVertex( 5, 0,  fgkCoolPipeSuppWidthExt/2.);
2976   side1->SetVertex( 6, fgkCoolPipeSuppMaxLength/2.,
2977                        fgkCoolPipeSuppWidthExt/2.);
2978   side1->SetVertex( 7, fgkCoolPipeSuppMaxLength/2.,
2979                        -fgkCoolPipeSuppWidthExt/2.);
2980
2981   TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1",0,
2982                                  - fgkCoolPipeSuppAxeDist
2983                                  + fgkCoolPipeSuppWidthExt/2., 0);
2984   side1Tr->RegisterYourself();
2985   TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2",0,
2986                                  - fgkCoolPipeSuppAxeDist
2987                                  + fgkCoolPipeSuppWidthExt*3/2.
2988                                  + fgkCoolPipeSuppWidthIn,0);
2989   side2Tr->RegisterYourself();
2990
2991   TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddle",
2992                          (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
2993                          fgkCoolPipeSuppWidthIn/2., fgkCoolPipeSuppHeight/2.);
2994   TGeoTranslation *middleTr =
2995     new TGeoTranslation("ITSsddCPStr3",
2996                         (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
2997                         -fgkCoolPipeSuppAxeDist+fgkCoolPipeSuppWidthExt
2998                         +fgkCoolPipeSuppWidthIn/2., 0);
2999   middleTr->RegisterYourself();
3000
3001   TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBox",
3002                                   fgkCoolPipeSuppTongW/4.,
3003                                   (fgkCoolPipeSuppFulWidth
3004                                    - 2*fgkCoolPipeSuppWidthExt
3005                                    - fgkCoolPipeSuppWidthIn)/2,
3006                                   fgkCoolPipeSuppHeight/2.);
3007
3008   TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTr",
3009                                   fgkCoolPipeSuppTongW/4.,
3010                                   - fgkCoolPipeSuppAxeDist
3011                                   + fgkCoolPipeSuppFulWidth
3012                                   - axeBox->GetDY(), 0);
3013   axeBoxTr->RegisterYourself();
3014
3015   TGeoTube *axe = new TGeoTube("ITSsddCPSaxe",0,fgkCoolPipeSuppHoleDiam/2.,
3016                                fgkCoolPipeSuppTongW/4.);
3017
3018   TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRot",90,90,0);
3019   TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTr",
3020                                  fgkCoolPipeSuppTongW/4.,0,0,axeRot);
3021   axeTrans->RegisterYourself();
3022   //delete axeRot; // make the code crash, no idea of why !!!
3023
3024   if(GetDebug(3)){
3025     middle->InspectShape();
3026     axe->InspectShape();
3027   };
3028
3029   TGeoMedium *rytonSDD = GetMedium("RYTON$");
3030
3031   TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
3032                                         "ITSsddCoolPipeSuppShapeL",
3033                                         "ITSsddCPSmiddle:ITSsddCPStr3"
3034                                         "+ITSsddCPSside1:ITSsddCPStr1"
3035                                         "+ITSsddCPSside1:ITSsddCPStr2"
3036                                         "+ITSsddCPSaxeBox:ITSsddCPSAxBoxTr"
3037                                         "-ITSsddCPSaxe:ITSsddCPSaxeTr");
3038   TGeoVolume *coolPipeSupp = new  TGeoVolume("ITSsddCoolPipeSupportL",
3039                                              coolPipeSuppShape, rytonSDD);
3040
3041   coolPipeSupp->SetLineColor(fColorRyton);
3042
3043   return coolPipeSupp;
3044 }
3045
3046
3047 //________________________________________________________________________
3048 TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() {
3049 //
3050 //Create half of the cooling pipe support (ALR-0752/3)
3051 //
3052
3053   Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
3054
3055   TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
3056   side1->SetName("ITSsddCPSside1R");
3057   side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
3058   side1->SetVertex( 1, -(fgkCoolPipeSuppMaxLength/2.-diffX),
3059                        -fgkCoolPipeSuppWidthExt/2.);
3060   side1->SetVertex( 2, -(fgkCoolPipeSuppMaxLength/2.-diffX),
3061                        fgkCoolPipeSuppWidthExt/2.);
3062   side1->SetVertex( 3, 0,  fgkCoolPipeSuppWidthExt/2.);
3063   side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
3064   side1->SetVertex( 5, -fgkCoolPipeSuppMaxLength/2.,
3065                        -fgkCoolPipeSuppWidthExt/2.);
3066   side1->SetVertex( 6, -fgkCoolPipeSuppMaxLength/2.,
3067                        fgkCoolPipeSuppWidthExt/2.);
3068   side1->SetVertex( 7, 0,  fgkCoolPipeSuppWidthExt/2.);
3069
3070   TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1R",0,
3071                                  - fgkCoolPipeSuppAxeDist
3072                                  + fgkCoolPipeSuppWidthExt/2., 0);
3073   side1Tr->RegisterYourself();
3074   TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2R",0,
3075                                  - fgkCoolPipeSuppAxeDist
3076                                  + fgkCoolPipeSuppWidthExt*3/2.
3077                                  + fgkCoolPipeSuppWidthIn, 0);
3078   side2Tr->RegisterYourself();
3079
3080   TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddleR",
3081                                   (fgkCoolPipeSuppMaxLength/2.
3082                                    - fgkCoolPipeSuppSlitL)/2.,
3083                                   fgkCoolPipeSuppWidthIn/2.,
3084                                   fgkCoolPipeSuppHeight/2.);
3085   TGeoTranslation *middleTr =
3086     new TGeoTranslation("ITSsddCPStr3R",
3087                         -( fgkCoolPipeSuppMaxLength/2.
3088                            -fgkCoolPipeSuppSlitL)/2.,
3089                         -fgkCoolPipeSuppAxeDist + fgkCoolPipeSuppWidthExt
3090                         + fgkCoolPipeSuppWidthIn/2.,0);
3091   middleTr->RegisterYourself();
3092
3093   TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBoxR",
3094                                   fgkCoolPipeSuppTongW/4.,
3095                                   (fgkCoolPipeSuppFulWidth
3096                                    - 2*fgkCoolPipeSuppWidthExt
3097                                    - fgkCoolPipeSuppWidthIn)/2,
3098                                   fgkCoolPipeSuppHeight/2.);
3099
3100   TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTrR",
3101                                   - fgkCoolPipeSuppTongW/4.,
3102                                   - fgkCoolPipeSuppAxeDist
3103                                   + fgkCoolPipeSuppFulWidth
3104                                   - axeBox->GetDY(),0);
3105   axeBoxTr->RegisterYourself();
3106
3107   TGeoTube *axe = new TGeoTube("ITSsddCPSaxeR",0,fgkCoolPipeSuppHoleDiam/2.,
3108                                fgkCoolPipeSuppTongW/4.);
3109
3110   TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRotR",90,90,0);
3111   TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTrR",
3112                                                 -fgkCoolPipeSuppTongW/4.,0,0,axeRot);
3113   axeTrans->RegisterYourself();
3114   //delete axeRot;
3115
3116   if(GetDebug(3)){
3117     middle->InspectShape();
3118     axe->InspectShape();
3119   };
3120
3121   TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
3122                                       "ITSsddCoolPipeSuppShapeR",
3123                                       "ITSsddCPSmiddleR:ITSsddCPStr3R"
3124                                       "+ITSsddCPSside1R:ITSsddCPStr1R"
3125                                       "+ITSsddCPSside1R:ITSsddCPStr2R"
3126                                       "+ITSsddCPSaxeBoxR:ITSsddCPSAxBoxTrR"
3127                                       "-ITSsddCPSaxeR:ITSsddCPSaxeTrR");
3128
3129   TGeoMedium *rytonSDD = GetMedium("RYTON$");
3130   TGeoVolume *coolPipeSupp = new TGeoVolume( "ITSsddCoolPipeSupportR",
3131                                              coolPipeSuppShape, rytonSDD);
3132   coolPipeSupp->SetLineColor(fColorRyton);
3133
3134   return coolPipeSupp;
3135 }
3136
3137 //________________________________________________________________________
3138 TGeoVolume* AliITSv11GeometrySDD::CreateBaseThermalBridge() {
3139   //
3140   // based on ALR 0752/8
3141   //
3142
3143   Double_t dy = fgkBTBaxisAtoBase - fgkRadiusBminBTB - fgkBTBthick;
3144
3145   Double_t base1width = fgkBTBwidth - fgkBTBaxisAtoBottom - fgkRadiusBminBTB
3146                         - (fgkRadiusAminBTB+fgkBTBthick);
3147   TGeoBBox *base1 = new TGeoBBox( "ITSsddBTBbase1", base1width/2.,
3148                                   fgkBTBthick/2., fgkBTBlength/2.);
3149   TGeoTranslation *base1Tr = new TGeoTranslation("ITSsddBTBtr1",
3150                                  fgkBTBaxisAtoBottom-fgkBTBwidth+base1width/2.,
3151                                  -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
3152   base1Tr->RegisterYourself();
3153
3154   Double_t base2width = fgkBTBaxisAtoBottom - fgkRadiusAminBTB - fgkBTBthick
3155                         - fgkRadiusBminBTB;
3156   TGeoBBox *base2 = new TGeoBBox( "ITSsddBTBbase2", base2width/2.,
3157                                   fgkBTBthick/2., fgkBTBlength/2.);
3158   TGeoTranslation *base2Tr = new TGeoTranslation("ITSsddBTBtr2",
3159                                  fgkBTBaxisAtoBottom - base2width/2.,
3160                                  -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
3161   base2Tr->RegisterYourself();
3162
3163   TGeoBBox *side = new TGeoBBox( "ITSsddBTBside",
3164                                  fgkBTBthick/2., dy/2., fgkBTBlength/2.);
3165   TGeoTranslation *sideTr1 = new TGeoTranslation("ITSsddBTBsideTr1",
3166                                  -fgkRadiusAminBTB-fgkBTBthick/2., -dy/2., 0);
3167   TGeoTranslation *sideTr2 = new TGeoTranslation("ITSsddBTBsideTr2",
3168                                  fgkRadiusAminBTB+fgkBTBthick/2., -dy/2., 0);
3169   sideTr1->RegisterYourself();
3170   sideTr2->RegisterYourself();
3171
3172   TGeoBBox *hole = new TGeoBBox( "ITSsddBTBhole", fgkBTBHolewidth/2.,
3173                                  fgkBTBthick/2., fgkBTBHoleLength/2.);
3174   TGeoTranslation *holeTr1 = new TGeoTranslation("ITSsddBTBholeTr1",
3175                                  - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
3176                                  - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
3177                                  fgkBTBHoleRefY+(fgkBTBHoleLength-fgkBTBlength)/2.);
3178   TGeoTranslation *holeTr2 = new TGeoTranslation("ITSsddBTBholeTr2",
3179                                  - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
3180                                  - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
3181                                  - fgkBTBHoleRefY-(fgkBTBHoleLength-fgkBTBlength)/2.);
3182   holeTr1->RegisterYourself();
3183   holeTr2->RegisterYourself();
3184
3185   Double_t radiusAmaxBTB = fgkRadiusAminBTB + fgkBTBthick;
3186   TGeoTubeSeg *mainAxis = new TGeoTubeSeg( "ITSsddBTBmainAxis",
3187                                            fgkRadiusAminBTB, radiusAmaxBTB,
3188                                            fgkBTBlength/2., 0., 180.);
3189   TGeoTubeSeg *round1 = new TGeoTubeSeg( "ITSsddBTBround1",
3190                            fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
3191                            fgkBTBlength/2., 270., 360.);
3192   TGeoTranslation *roundTr1 = new TGeoTranslation("ITSsddBTBround1Tr",
3193                                   -(fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
3194                                   -dy, 0);
3195   roundTr1->RegisterYourself();
3196
3197   TGeoTubeSeg *round2 = new TGeoTubeSeg( "ITSsddBTBround2",
3198                            fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
3199                            fgkBTBlength/2., 180., 270.);
3200   TGeoTranslation *roundTr2 = new TGeoTranslation("ITSsddBTBround2Tr",
3201                                   (fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
3202                                   -dy, 0);
3203   roundTr2->RegisterYourself();
3204
3205   TGeoCompositeShape *sBaseThermalBridge = new TGeoCompositeShape(
3206                                       "ITSsddBaseThermalBridgeShape",
3207                                       "ITSsddBTBbase1:ITSsddBTBtr1"
3208                                       "+ ITSsddBTBbase2:ITSsddBTBtr2"
3209                                       "+ ITSsddBTBround1:ITSsddBTBround1Tr"
3210                                       "+ ITSsddBTBround2:ITSsddBTBround2Tr"
3211                                       "+ ITSsddBTBside:ITSsddBTBsideTr1"
3212                                       "+ ITSsddBTBside:ITSsddBTBsideTr2"
3213                                       "- ITSsddBTBhole:ITSsddBTBholeTr1"
3214                                       "- ITSsddBTBhole:ITSsddBTBholeTr2"
3215                                       "+ ITSsddBTBmainAxis");
3216
3217     if(GetDebug(3)){// Remove compiler warning.
3218         base1->InspectShape();
3219         base2->InspectShape();
3220         side->InspectShape();
3221         hole->InspectShape();
3222         mainAxis->InspectShape();
3223         round1->InspectShape();
3224         round2->InspectShape();
3225     };
3226
3227   TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$");
3228   TGeoVolume *vBaseThermalBridge = new TGeoVolume( "ITSsddBaseThermalBridge",
3229                                                    sBaseThermalBridge,
3230                                                    carbonFiberLadderStruct);
3231
3232   vBaseThermalBridge->SetLineColor(fColorCarbonFiber);
3233   return vBaseThermalBridge;
3234 }
3235
3236
3237 //________________________________________________________________________
3238 TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) {
3239   //
3240   // Return an assembly containing a end of a CF ladder.
3241   //
3242
3243   TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); // ITSsddCarbonM55J
3244   TGeoMedium *stesalite       = GetMedium("G10FR4$");
3245   TGeoMedium *phynoxSDD       = GetMedium("INOX$");
3246   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
3247
3248   Double_t length        = (fgkLay3LadderLength-fgkLay3Ndet*fgkSegmentLength)/2.;
3249   Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH;
3250   Double_t underSegDH    = fLay3LadderUnderSegDH;
3251   Double_t footDZ    = fgkRubyZladd3 - fgkLay3Ndet*fgkSegmentLength/2 - length/2;
3252   // footDZ is also where to place the ruby's center in local Z
3253   Double_t coolPipeEndLen = (fgkCoolPipeLay3Len-fgkSegmentLength*fgkLay3Ndet)/2;
3254
3255   if (iLay==3) {
3256   } else if (iLay==4) {
3257     length         = (fgkLay4LadderLength-fgkLay4Ndet*fgkSegmentLength)/2.;
3258     coolPipeSuppH  = fgkLay4CoolPipeSuppH;
3259     underSegDH     = fLay4LadderUnderSegDH;
3260     footDZ         = fgkRubyZladd4 - fgkLay4Ndet*fgkSegmentLength/2 - length/2;
3261     coolPipeEndLen = (fgkCoolPipeLay4Len-fgkSegmentLength*fgkLay4Ndet)/2;
3262   } else {
3263     printf("error in AliITSv11GeometrySDD::CreateEndLadder: Wrong layer");
3264     return 0;
3265   };
3266
3267   Double_t tDY = (- fgkLadderSegBoxDH/2       //space left on top of the ladder
3268                   + underSegDH/2);          //space under ladder segment
3269         // here tDY is not the same as for the segment because the end ladder
3270         // does not have a space under it, inside the general ladder volume.
3271   Double_t segmentLength   = fgkSegmentLength;
3272   Double_t topCornerLength = fgkSegmentLength/2.-fgkLay4LaddTopCornerEnd;
3273
3274   TGeoVolumeAssembly *virtualEnd = new TGeoVolumeAssembly("ITSsddEnd");
3275
3276   //**********************************
3277   // coding real matter :
3278   //**********************************
3279   Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
3280   Double_t halfTheta   = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
3281   Double_t beta        = (TMath::Pi()-2.*halfTheta)/4.;
3282   Double_t alpha       = TMath::Pi()*3./4. - halfTheta/2.;
3283
3284   //--- The 3 V shape corners of the Carbon Fiber Ladder
3285   //--- the top V
3286   TGeoArb8 *cfLaddTop1 = CreateLadderSide("CFladdTopCornerV1shape",
3287                                           topCornerLength/2., halfTheta, -1,
3288                                           fgkLadderLa, fgkLadderHa, fgkLadderl);
3289   TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerV1",
3290                                   cfLaddTop1,carbonFiberLadderStruct);
3291   cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
3292   TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerV2shape",
3293                                            topCornerLength/2., halfTheta, 1,
3294                                            fgkLadderLa, fgkLadderHa, fgkLadderl);
3295   TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerV2",
3296                                   cfLaddTop2,carbonFiberLadderStruct);
3297   cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
3298   TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2+tDY,
3299                                                 -(length-topCornerLength)/2.);
3300   virtualEnd->AddNode(cfLaddTopVol1, 1, trTop1);
3301   virtualEnd->AddNode(cfLaddTopVol2, 1, trTop1);
3302
3303   //--- the 2 side V
3304   TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerV1shape",
3305                                             length/2., beta, -1,
3306                                             fgkLadderLb, fgkLadderHb, fgkLadderl);
3307   TGeoVolume *cfLaddSideVol1 = new TGeoVolume("ITSsddCFladdSideCornerV1",
3308                                    cfLaddSide1,carbonFiberLadderStruct);
3309   cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
3310   TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerV2shape",
3311                                             length/2., beta, 1,
3312                                             fgkLadderLb, fgkLadderHb, fgkLadderl);
3313   TGeoVolume *cfLaddSideVol2 = new TGeoVolume("ITSsddCFladdSideCornerV2",
3314                                    cfLaddSide2,carbonFiberLadderStruct);
3315   cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
3316   Double_t dYTranslation = ( fgkLadderHeight/2. - 0.5*fgkLadderWidth*
3317                              TMath::Tan(beta) - fgkLadderBeamRadius );
3318
3319   // because center of the triangle doesn't correspond to virtual vol. center
3320   Double_t distCenterSideDown =  0.5*fgkLadderWidth/TMath::Cos(beta);
3321   TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
3322                                              alpha*TMath::RadToDeg());
3323   AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation+tDY, 0);
3324   TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown, 0,
3325                                              -alpha*TMath::RadToDeg());
3326   AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation+tDY, 0);
3327   virtualEnd->AddNode(cfLaddSideVol1, 1, ctSideR);
3328   virtualEnd->AddNode(cfLaddSideVol2, 1, ctSideR);
3329   virtualEnd->AddNode(cfLaddSideVol1, 2, ctSideL);
3330   virtualEnd->AddNode(cfLaddSideVol2, 2, ctSideL);
3331
3332   //--- The beams
3333   // Beams on the sides
3334   Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
3335                   TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
3336
3337   //Euler rotation : about Z, then new X, then new Z
3338   TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
3339                         -beamPhiPrime*TMath::RadToDeg(), -90);
3340   TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
3341                         beamPhiPrime*TMath::RadToDeg(), -90);
3342   TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
3343                         beamPhiPrime*TMath::RadToDeg(), -90);
3344   TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
3345                         -beamPhiPrime*TMath::RadToDeg(), -90);
3346   TGeoCombiTrans *beamTransf1 = new TGeoCombiTrans(0.5*triangleHeight*
3347                                                    TMath::Tan(halfTheta),
3348                                               fgkLadderBeamRadius/2. + tDY,
3349                                  -length/2 + segmentLength/8, beamRot1);
3350   TGeoCombiTrans *beamTransf3 = new TGeoCombiTrans( 0.5*triangleHeight*
3351                                                     TMath::Tan(halfTheta),
3352                                                  fgkLadderBeamRadius/2.+tDY,
3353                                 -length/2 + 3*segmentLength/8, beamRot2);
3354   TGeoCombiTrans *beamTransf5 = new TGeoCombiTrans(-0.5*triangleHeight*
3355                                                    TMath::Tan(halfTheta),
3356                                                 fgkLadderBeamRadius/2.+tDY,
3357                                  -length/2 + segmentLength/8, beamRot3);
3358   TGeoCombiTrans *beamTransf7 = new TGeoCombiTrans(-0.5*triangleHeight*
3359                                                    TMath::Tan(halfTheta),
3360                                               fgkLadderBeamRadius/2. + tDY,
3361                                  -length/2+3*segmentLength/8, beamRot4);
3362
3363   virtualEnd->AddNode(fLaddSegCommonVol[6], 1, beamTransf1);
3364   virtualEnd->AddNode(fLaddSegCommonVol[6], 2, beamTransf3);
3365   virtualEnd->AddNode(fLaddSegCommonVol[6], 3, beamTransf5);
3366   virtualEnd->AddNode(fLaddSegCommonVol[6], 4, beamTransf7);
3367
3368   //--- Beams of the bottom
3369   TGeoRotation *bottomBeamRot1 = new TGeoRotation("",90, 90, 90);
3370
3371   /* Not there actually
3372   TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
3373                                  fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
3374   TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
3375                                    bottomBeam1, carbonFiberLadderStruct);
3376   bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
3377
3378   TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans(0,
3379                             -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,
3380                             -length/2+fgkSegmentLength/2, bottomBeamRot1);
3381   virtualEnd->AddNode(bottomBeam1Vol, 1, bottomBeamTransf1);
3382 */
3383   TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
3384                                  fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
3385   TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
3386                                    bottomBeam2, carbonFiberLadderStruct);
3387   bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
3388   TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
3389      -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,-length/2,bottomBeamRot1);
3390   virtualEnd->AddNode(bottomBeam2Vol, 1, bottomBeamTransf2);
3391
3392   //**********************************
3393   //the cooling pipe supports
3394   Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
3395                                fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
3396
3397   Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
3398                            (triangleHeight+triangleCPaxeDist/
3399                             TMath::Sin(halfTheta)-coolPipeSuppH);
3400
3401   if (fAddCoolingSyst) {
3402     TGeoRotation *rotCPS2 = new TGeoRotation("",-halfTheta*TMath::RadToDeg(),-90, 90);
3403     TGeoRotation *rotCPS1 = new TGeoRotation("", halfTheta*TMath::RadToDeg(),-90,-90);
3404     TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
3405                                                    -fgkLadderHeight/2.+ tDY +
3406                                                    coolPipeSuppH+fgkLadderBeamRadius,
3407                                                    -length/2., rotCPS1);
3408     TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
3409                                                    -fgkLadderHeight/2.+ tDY +
3410                                                    coolPipeSuppH+fgkLadderBeamRadius,
3411                                                    -length/2., rotCPS2);
3412
3413     virtualEnd->AddNode(fCoolPipeSupportL, 1, transCPS1);
3414     virtualEnd->AddNode(fCoolPipeSupportR, 1, transCPS4);
3415   };
3416
3417   //**********************************
3418   //--- The stesalite foot of the ladder
3419
3420   Double_t footDY = -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY
3421                     - fgkLadFootY/2+fgkLadFingerPrintY;
3422
3423   TGeoTranslation *footTr = new TGeoTranslation("SDDfootTr",0,footDY,footDZ);
3424   virtualEnd->AddNode(fLadderFoot, 1, footTr);
3425
3426   //=====================================
3427   //--- cooling pipe
3428
3429   if (fAddCoolingSyst) {
3430
3431     TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
3432                                        -fgkLadderHeight/2.+ tDY +
3433                                        coolPipeSuppH + fgkLadderBeamRadius,
3434                                        -length/2.+coolPipeEndLen/2.);
3435     TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
3436                                    -fgkLadderHeight/2. + tDY +
3437                                     fgkLadderBeamRadius + coolPipeSuppH,
3438                                     -length/2.+coolPipeEndLen/2.);
3439
3440     TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
3441                                                fgkCoolPipeOuterDiam/2,
3442                                                coolPipeEndLen/2);
3443     TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
3444                                           coolPipeEndLen/2);
3445
3446     TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipeEnd",
3447                                              coolingPipeShape, phynoxSDD );
3448     coolingPipe->SetLineColor(fColorPhynox);
3449     TGeoVolume *cooler = new  TGeoVolume("ITSsddCoolingEndLiquid",coolerShape,
3450                                          coolerMediumSDD );
3451
3452     virtualEnd->AddNode(coolingPipe, 1, pipeTr1);
3453     virtualEnd->AddNode(coolingPipe, 2, pipeTr2);
3454     if (fCoolingOn) {
3455       virtualEnd->AddNode(cooler, 1, pipeTr1);
3456       virtualEnd->AddNode(cooler, 2, pipeTr2);
3457     };
3458   };
3459
3460   //=====================================
3461   //--- HV cable guide
3462
3463
3464   TGeoBBox* guideHVbox = new TGeoBBox("guideHVbox",fgkHVguideX1/2,
3465                                       fgkHVguideY1/2,fgkHVguideZ1/2);
3466   TGeoVolume *guideHV = new TGeoVolume("guideHV",guideHVbox,stesalite);
3467
3468   TGeoTranslation* guideHVtr = new TGeoTranslation(fgkHVguideDX,
3469      -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY-fgkHVguideY1/2,
3470      footDZ+fgkLadFootZ/2+fgkHVguideZ1/2-(fgkHVguideSuppFullZ-fgkHVguideZ2));
3471   virtualEnd->AddNode(guideHV, 1, guideHVtr);
3472
3473   //=====================================
3474   //--- raccordo
3475   Double_t raccordFullLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
3476   TGeoTranslation *trRaccordo1 = new TGeoTranslation("trRaccordo1",-coolPipeSuppL,
3477                                                      -fgkLadderHeight/2.+ tDY +
3478                                                      coolPipeSuppH+fgkLadderBeamRadius,
3479                                             -length/2.+coolPipeEndLen+raccordFullLen/2);
3480   TGeoTranslation *trRaccordo2 = new TGeoTranslation("trRaccordo2", coolPipeSuppL,
3481                                                      -fgkLadderHeight/2.+ tDY +
3482                                                      coolPipeSuppH+fgkLadderBeamRadius,
3483                                             -length/2.+coolPipeEndLen+raccordFullLen/2);
3484
3485   virtualEnd->AddNode(fRaccordoL, 1, trRaccordo1);
3486   virtualEnd->AddNode(fRaccordoL, 2, trRaccordo2);
3487
3488   if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
3489
3490   return virtualEnd;
3491 }
3492
3493 //________________________________________________________________________
3494 TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateLadderFoot() {
3495
3496   //--- The stesalite foot of the ladder
3497   // Are missing :
3498   // The 2 screw holes on the left part
3499   // the small holes at each corner of the ruby cage (diam 2mm)
3500   // the really small level difference of 0.3mm on the bottom
3501
3502
3503   TGeoMedium *stesalite = GetMedium("G10FR4$");
3504
3505   TGeoVolumeAssembly *virtualFoot = new TGeoVolumeAssembly("ITSsddFoot");
3506
3507   Double_t epsilon = 2e-10;
3508   TGeoBBox *ladFootBox1 = new TGeoBBox("ladFootBox1",fgkLadBox1X/2, fgkLadFootY/2,
3509                                        fgkLadFootZ/2);
3510   TGeoTranslation *ladFootBox1Tr = new TGeoTranslation("ladFootBox1Tr",
3511                                                        fgkLadFootX/2-fgkLadBox1X/2,0,0);
3512   TGeoBBox *ladFingerPrint = new TGeoBBox("ladFingerPrint",fgkLadFingerPrintX/2,
3513                                           fgkLadFingerPrintY/2+epsilon, fgkLadFootZ/2+epsilon);
3514
3515   TGeoTranslation *ladFingerPrintTr = new TGeoTranslation("ladFingerPrintTr",
3516                             fgkLadFootX/2-fgkLadFingerPrintBorder-fgkLadFingerPrintX/2,
3517                             fgkLadFootY/2-fgkLadFingerPrintY/2+epsilon,
3518                             0);
3519
3520   TGeoBBox *rubyCageHole = new TGeoBBox("rubyCageHole",fgkRubyCageHoleX/2,
3521                                         fgkRubyCageHoleY/2+epsilon, fgkRubyCageHoleZ/2);
3522
3523   TGeoTranslation *rubyCageHoleTr = new TGeoTranslation("rubyCageHoleTr",
3524                                  fgkLadFootX/2-(fgkLadFootX/2-fgkRubyDX)+fgkRubyCageAxisShift,
3525                                  fgkLadFootY/2-fgkRubyCageHoleY/2,0);
3526
3527   double rubyScrewHoleLen = fgkLadFootX/2-fgkRubyDX;
3528   TGeoTube *rubyScrewHole = new TGeoTube("rubyScrewHole", 0,fgkScrewM4diam/2,
3529                             rubyScrewHoleLen/2);
3530
3531   TGeoRotation *rot9090 = new TGeoRotation("",90,90,0);
3532   TGeoCombiTrans *rubyScrewHoleTr = new TGeoCombiTrans("rubyScrewHoleTr",
3533                                     fgkLadFootX/2-rubyScrewHoleLen/2,
3534                                     -fgkRubyScrewShiftToCenterY, 0, rot9090);
3535
3536   Double_t rubyHoleLen = fgkLadFootY-fgkRubyCageHoleY;
3537   TGeoTube *rubyHole = new TGeoTube("rubyHole", 0,fgkRubyHoleDiam/2,
3538                                     rubyHoleLen/2);
3539
3540   TGeoRotation *rot90 = new TGeoRotation("",0,90,0);
3541   TGeoCombiTrans *rubyHoleTr = new TGeoCombiTrans("rubyHoleTr", fgkRubyDX,
3542                                    -(fgkLadFootY-rubyHoleLen)/2, 0, rot90);
3543
3544   ladFootBox1Tr->RegisterYourself();
3545   ladFingerPrintTr->RegisterYourself();
3546   rubyCageHoleTr->RegisterYourself();
3547   rubyScrewHoleTr->RegisterYourself();
3548   rubyHoleTr->RegisterYourself();
3549
3550   TGeoCompositeShape *footRightPart = new TGeoCompositeShape(
3551               "ladFootBox1:ladFootBox1Tr-(ladFingerPrint:ladFingerPrintTr"
3552               "+rubyCageHole:rubyCageHoleTr+rubyScrewHole:rubyScrewHoleTr"
3553               "+rubyHole:rubyHoleTr)");
3554   TGeoVolume *vFootRightPart = new TGeoVolume("vFootRightPart",
3555                                               footRightPart,stesalite);
3556   vFootRightPart->SetLineColor(fColorStesalite);
3557
3558   virtualFoot->AddNode(vFootRightPart, 1, 0);
3559
3560
3561   //--- This was the right part of the foot, now let's do the middle
3562   //--- and the right parts
3563
3564   Double_t middleX = fgkLadFootX-fgkLadBox1X-fgkLadFingerPrintX-fgkLadFingerPrintBorder;
3565   TGeoBBox *footMiddle = new TGeoBBox("footMiddle", middleX/2, fgkLadFootMiddleY/2,
3566                                       fgkLadFootZ/2);
3567   TGeoTranslation *middleXTr = new TGeoTranslation("middleXTr",
3568                                    fgkLadFootX/2-fgkLadBox1X-middleX/2,
3569                                    fgkLadFootY/2-fgkLadFootMiddleY/2, 0);
3570
3571   TGeoVolume *vFootMiddle = new TGeoVolume("vFootMiddle", footMiddle,stesalite);
3572   vFootMiddle->SetLineColor(fColorStesalite);
3573   virtualFoot->AddNode(vFootMiddle, 1, middleXTr);
3574
3575   //--
3576   TGeoBBox *footLeftLadFinger = new TGeoBBox("footLeftLadFinger", fgkLadFingerPrintX/2,
3577                                              (fgkLadFootY-fgkLadFingerPrintY)/2,
3578                                              fgkLadFootZ/2);
3579   TGeoTranslation *footLeftLadFingerTr = new TGeoTranslation("footLeftLadFingerTr",
3580                                    -fgkLadFootX/2+fgkLadFingerPrintBorder+fgkLadFingerPrintX/2,
3581                                    -fgkLadFingerPrintY/2, 0);
3582   TGeoVolume *vFootLeftLadFinger = new TGeoVolume("vFootLeftLadFinger",footLeftLadFinger,
3583                                                   stesalite);
3584   vFootLeftLadFinger->SetLineColor(fColorStesalite);
3585   virtualFoot->AddNode(vFootLeftLadFinger, 1, footLeftLadFingerTr);
3586
3587   //--
3588   TGeoBBox *footLeft = new TGeoBBox("footLeft", fgkLadFingerPrintBorder/2,
3589                                     fgkLadFootY/2,
3590                                     fgkLadFootZ/2);
3591   TGeoTranslation *footLeftTr = new TGeoTranslation("footLeftTr",
3592                                    -fgkLadFootX/2+fgkLadFingerPrintBorder/2,
3593                                     0, 0);
3594   TGeoVolume *vFootLeft = new TGeoVolume("vFootLeft",footLeft,stesalite);
3595   vFootLeft->SetLineColor(fColorStesalite);
3596   virtualFoot->AddNode(vFootLeft, 1, footLeftTr);
3597
3598   if(GetDebug(3)){ // Remove compiler warning.
3599     ladFingerPrint->InspectShape();
3600     ladFootBox1->InspectShape();
3601     rubyCageHole->InspectShape();
3602     rubyScrewHole->InspectShape();
3603     rubyHole->InspectShape();
3604   }
3605
3606   return virtualFoot;
3607 }
3608
3609 //________________________________________________________________________
3610 TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateCarlosCard(Int_t iLay) {
3611   //
3612   // return an assembly containing the CARLOS end-ladder board
3613   // and the heat bridge
3614   //
3615
3616   (void) iLay;
3617   TGeoMedium *glassFiber  = GetMedium("GLASS FIBER$");// glassFiber
3618   TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip
3619   TGeoMedium *plastiChip  = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
3620   TGeoMedium *copper      = GetMedium("COPPER$");
3621   TGeoMedium *alCu12SDD   = GetMedium("ALCU12$"); // ITSsddAlCu12
3622   TGeoMedium *stainless   = GetMedium("AISI304L$"); // for screws
3623
3624   //=========================================
3625   // cooling support of the Carlos card (HeatBridge):
3626   TGeoVolumeAssembly *assemblySupCarlos = new TGeoVolumeAssembly("assemblySupCarlos");
3627
3628   TGeoBBox *supCarlosBoard1 = new TGeoBBox("",fgkCarlosSuppX1/2,fgkCarlosSuppY1/2,
3629                                            fgkCarlosSuppZ/2);
3630   TGeoBBox *supCarlosBoard2 = new TGeoBBox("",fgkCarlosSuppX2/2,fgkCarlosSuppY2/2,
3631                                            fgkCarlosSuppZ/2);
3632   TGeoVolume *vSupCarlosBoard1 = new TGeoVolume("vSupCarlosBoard1",
3633                                                 supCarlosBoard1, alCu12SDD);
3634   TGeoVolume *vSupCarlosBoard2 = new TGeoVolume("vSupCarlosBoard2",
3635                                                 supCarlosBoard2, alCu12SDD);
3636   vSupCarlosBoard1->SetLineColor(4);
3637   vSupCarlosBoard2->SetLineColor(4);
3638
3639
3640   Double_t shiftGlob = -fgkCarlosSuppZ/2+fgkCarlosSuppTopLen;
3641   // shift of the main planes in the direction of their width
3642   // the center is fixed at the center of the 2 small fixing arms on each sides.
3643   //shiftGlob=0.5;
3644
3645   shiftGlob+= 0.5*fgkCarlosSuppY3/cos((90-fgkCarlosSuppAngle)*TMath::DegToRad());
3646   shiftGlob-= 0.5*fgkCarlosSuppY2*tan((90-fgkCarlosSuppAngle)*TMath::DegToRad());
3647   Double_t shiftGlobY = shiftGlob*sin(fgkCarlosSuppAngle*TMath::DegToRad());
3648   Double_t shiftGlobZ = shiftGlob*cos(fgkCarlosSuppAngle*TMath::DegToRad());
3649
3650   TGeoTranslation *carlosSupTr1 = new TGeoTranslation( -fgkCarlosSuppX2/2,
3651                                  (-fgkCarlosSuppY1+fgkCarlosSuppY2)/2+shiftGlobY,
3652                                                        +shiftGlobZ);
3653
3654   TGeoTranslation *carlosSupTr2 = new TGeoTranslation( fgkCarlosSuppX1/2,
3655                                                      shiftGlobY,
3656                                                      shiftGlobZ);
3657
3658   assemblySupCarlos->AddNode(vSupCarlosBoard1, 0, carlosSupTr1);
3659   assemblySupCarlos->AddNode(vSupCarlosBoard2, 0, carlosSupTr2);
3660
3661   //=========================================
3662   // fixing arm of the cooling support :
3663   TGeoBBox *supCarlosBoard3 = new TGeoBBox("",fgkCarlosSuppX3/2,fgkCarlosSuppY3/2,
3664                                            fgkCarlosSuppZ3/2);
3665   TGeoVolume *vSupCarlosBoard3 = new TGeoVolume("vSupCarlosBoard3",
3666                                                 supCarlosBoard3, alCu12SDD);
3667   vSupCarlosBoard3->SetLineColor(4);
3668
3669   // screw inside :
3670   TGeoTube *littleScrew = new TGeoTube("littleScrew", 0, fgkLittleScrewR,
3671                                        fgkCarlosSuppY3/2);
3672   TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrew",
3673                                             littleScrew, stainless);
3674   TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
3675   TGeoCombiTrans *cbScrew1 = new TGeoCombiTrans(0, 0, fgkCarlosSuppZ3/2 -
3676                                                 fgkLittleScrewHeadR-0.07, rotScrew);
3677   TGeoCombiTrans *cbScrew2 = new TGeoCombiTrans(0, 0, -fgkCarlosSuppZ3/2 +
3678                                                 fgkLittleScrewHeadR+0.07, rotScrew);
3679   vSupCarlosBoard3->AddNode(vLittleScrew,1, cbScrew1);
3680   vSupCarlosBoard3->AddNode(vLittleScrew,2, cbScrew2);
3681
3682   TGeoRotation *carlosSupRot = new TGeoRotation("carlosSuppInvertAngle",
3683                                                  0, fgkCarlosSuppAngle, 0);
3684   TGeoCombiTrans *carlosSupTr3 = new TGeoCombiTrans((fgkCarlosSuppX1+
3685                                  fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
3686   TGeoCombiTrans *carlosSupTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3687                                  fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
3688   assemblySupCarlos->AddNode(vSupCarlosBoard3, 0, carlosSupTr3);
3689   assemblySupCarlos->AddNode(vSupCarlosBoard3, 1, carlosSupTr4);
3690
3691
3692   //=========================================
3693   // screws fixing the board on the U tube
3694   Double_t aaa = fgkCarlosSuppY3; // ???
3695   //Double_t aaa = fgkCarlosSuppY3/2 + fgkLittleScrewHeadH/2;
3696   Double_t bbb = fgkCarlosSuppZ3/2 - fgkLittleScrewHeadR;
3697   Double_t screw1y = ( aaa*cos(TMath::DegToRad()*fgkCarlosSuppAngle) -
3698                        bbb*sin(TMath::DegToRad()*fgkCarlosSuppAngle) );
3699   Double_t screw1z = ( aaa*sin(TMath::DegToRad()*fgkCarlosSuppAngle) +
3700                        bbb*cos(TMath::DegToRad()*fgkCarlosSuppAngle) )-0.07;
3701
3702   TGeoRotation *CarlosSuppRot = (TGeoRotation *)fCommonTr[0];
3703
3704   TGeoCombiTrans* lScrewTr1 = new TGeoCombiTrans((fgkCarlosSuppX1+
3705                               fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3706                               screw1y,screw1z, CarlosSuppRot);
3707
3708   TGeoCombiTrans* lScrewTr2 = new TGeoCombiTrans((fgkCarlosSuppX1+
3709                               fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3710                               screw1z,screw1y, CarlosSuppRot);
3711
3712   TGeoCombiTrans *lScrewTr3 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3713                               fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3714                               screw1y,screw1z, CarlosSuppRot);
3715
3716   TGeoCombiTrans *lScrewTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3717                               fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3718                               screw1z,screw1y, CarlosSuppRot);
3719
3720   assemblySupCarlos->AddNode(fCommonVol[0], 1, lScrewTr1);
3721   assemblySupCarlos->AddNode(fCommonVol[0], 2, lScrewTr2);
3722   assemblySupCarlos->AddNode(fCommonVol[0], 3, lScrewTr3);
3723   assemblySupCarlos->AddNode(fCommonVol[0], 4, lScrewTr4);
3724
3725   //=========================================
3726   // board
3727   Double_t p1[3], p2[3], vX[3] = {1,0,0};
3728   AliITSv11GeomCableFlat card1("cardCarlos1", fgkCarlosCardZ1, fgkCarlosCardY1); // name, width, thickness
3729   card1.SetNLayers(2);
3730   card1.SetLayer(0, fgkCarlosCardCuY, copper,     kOrange); // index, thickness, material, color
3731   card1.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY,   glassFiber, 30);
3732   card1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3733   p1[0] = -fgkCarlosCardX1/2;
3734   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3735   p1[2] = fgkCarlosCardShift;
3736   p2[0] = fgkCarlosCardX1/2;
3737   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3738   p2[2] = fgkCarlosCardShift;
3739   card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3740   card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3741   card1.CreateAndInsertBoxCableSegment(1,90);
3742
3743   AliITSv11GeomCableFlat card2("cardCarlos2", fgkCarlosCardZ2, fgkCarlosCardY1); // name, width, thickness
3744   card2.SetNLayers(2);
3745   card2.SetLayer(0, fgkCarlosCardCuY, copper,     kOrange); // index, thickness, material, color
3746   card2.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY,   glassFiber, 30);
3747   card2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3748
3749   p1[0] = -fgkCarlosCardX1/2;
3750   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3751   p1[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
3752
3753   p2[0] = -fgkCarlosCardX1/2 + fgkCarlosCardX2;
3754   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3755   p2[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
3756   card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3757   card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3758   card2.CreateAndInsertBoxCableSegment(1,90);
3759
3760   //=========================================
3761   // some chips on the board
3762
3763   AliITSv11GeomCableFlat u1("carlosCardU1", fgkCarlosU1Z, fgkCarlosU1Y); // name, width, thickness
3764   u1.SetNLayers(2);
3765   u1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3766   u1.SetLayer(1, fgkCarlosU1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3767   u1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3768
3769   p1[0] = fgkCarlosU1posX - fgkCarlosU1X/2;
3770   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
3771   p1[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
3772
3773   p2[0] = fgkCarlosU1posX + fgkCarlosU1X/2;
3774   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
3775   p2[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
3776   u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3777   u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3778   u1.CreateAndInsertBoxCableSegment(1,90);
3779
3780   //---
3781   AliITSv11GeomCableFlat u2("carlosCardU2", fgkCarlosU2Z, fgkCarlosU2Y); // name, width, thickness
3782   u2.SetNLayers(2);
3783   u2.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3784   u2.SetLayer(1, fgkCarlosU2Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3785   u2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3786
3787   p1[0] = fgkCarlosU2posX - fgkCarlosU2X/2;
3788   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
3789   p1[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
3790
3791   p2[0] = fgkCarlosU2posX + fgkCarlosU2X/2;
3792   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
3793   p2[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
3794   u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3795   u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3796   u2.CreateAndInsertBoxCableSegment(1,90);
3797
3798   //---
3799   AliITSv11GeomCableFlat u3("carlosCardU3", fgkCarlosU3Z, fgkCarlosU3Y); // name, width, thickness
3800   u3.SetNLayers(2);
3801   u3.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3802   u3.SetLayer(1, fgkCarlosU3Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3803   u3.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3804
3805   Double_t u3Y = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU3Y/2;
3806   p1[0] = fgkCarlosU3posX - fgkCarlosU3X/2;
3807   p1[1] = u3Y;
3808   p1[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
3809
3810   p2[0] = fgkCarlosU3posX + fgkCarlosU3X/2;
3811   p2[1] = u3Y;
3812   p2[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
3813   u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3814   u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3815   TGeoVolume *u3Vol = u3.CreateAndInsertBoxCableSegment(1,90);
3816
3817   //--- U4 is like U3 (?)
3818   TGeoCombiTrans *u4Trans = new TGeoCombiTrans;
3819   u4Trans->RotateX(90);
3820   u4Trans->SetTranslation(fgkCarlosU4posX, u3Y,
3821                           fgkCarlosCardShift + fgkCarlosU4posZ);
3822   assemblySupCarlos->AddNode(u3Vol, 2, u4Trans);
3823
3824   //---
3825   AliITSv11GeomCableFlat u17("carlosCardU17", fgkCarlosU17Z, fgkCarlosU17Y); // name, width, thickness
3826   u17.SetNLayers(2);
3827   u17.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3828   u17.SetLayer(1, fgkCarlosU17Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3829   u17.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3830
3831   p1[0] = fgkCarlosU17posX - fgkCarlosU17X/2;
3832   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
3833   p1[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
3834
3835   p2[0] = fgkCarlosU17posX + fgkCarlosU17X/2;
3836   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
3837   p2[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
3838   u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3839   u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3840   u17.CreateAndInsertBoxCableSegment(1,90);
3841
3842   //---
3843   AliITSv11GeomCableFlat u35("carlosCardU35", fgkCarlosU35Z, fgkCarlosU35Y); // name, width, thickness
3844   u35.SetNLayers(2);
3845   u35.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3846   u35.SetLayer(1, fgkCarlosU35Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3847   u35.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3848
3849   p1[0] = fgkCarlosU35posX - fgkCarlosU35X/2;
3850   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
3851   p1[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
3852
3853   p2[0] = fgkCarlosU35posX + fgkCarlosU35X/2;
3854   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
3855   p2[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
3856   u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3857   u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3858   u35.CreateAndInsertBoxCableSegment(1,90);
3859
3860   //---
3861   AliITSv11GeomCableFlat u36("carlosCardU36", fgkCarlosU36Z, fgkCarlosU36Y); // name, width, thickness
3862   u36.SetNLayers(2);
3863   u36.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3864   u36.SetLayer(1, fgkCarlosU36Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3865   u36.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3866
3867   p1[0] = fgkCarlosU36posX - fgkCarlosU36X/2;
3868   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
3869   p1[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
3870
3871   p2[0] = fgkCarlosU36posX + fgkCarlosU36X/2;
3872   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
3873   p2[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
3874   u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3875   u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3876   u36.CreateAndInsertBoxCableSegment(1,90);
3877
3878   //--- QZ1
3879   AliITSv11GeomCableFlat qz1("carlosCardQZ1", fgkCarlosQZ1Z, fgkCarlosQZ1Y); // name, width, thickness
3880   qz1.SetNLayers(2);
3881   qz1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3882   qz1.SetLayer(1, fgkCarlosQZ1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3883   qz1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3884
3885   p1[0] = fgkCarlosQZ1posX - fgkCarlosQZ1X/2;
3886   p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
3887   p1[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
3888
3889   p2[0] = fgkCarlosQZ1posX + fgkCarlosQZ1X/2;
3890   p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
3891   p2[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
3892   qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3893   qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3894   qz1.CreateAndInsertBoxCableSegment(1,90);
3895
3896   return assemblySupCarlos;
3897 }
3898
3899 //________________________________________________________________________
3900 Int_t AliITSv11GeometrySDD::CreateLVCard() {
3901   //
3902   // Creates the assemblies containing the LV cards (left and right)
3903   //
3904
3905   TGeoMedium *glassFiber  = GetMedium("GLASS FIBER$");// glassFiber
3906   TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip
3907   TGeoMedium *plastiChip  = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
3908   TGeoMedium *copper      = GetMedium("COPPER$");
3909   TGeoMedium *alCu12SDD   = GetMedium("ALCU12$"); // ITSsddAlCu12
3910   TGeoMedium *stainless   = GetMedium("AISI304L$"); // for screws
3911
3912   fCardLVL = new TGeoVolumeAssembly("ITSsddLVCardLeft");
3913   fCardLVR = new TGeoVolumeAssembly("ITSsddLVCardRight");
3914
3915   // we are going to use flat cable class to create multilayer box,
3916   // then we can use the pointers to created volumes to place them elsewhere
3917   Double_t p1[3], p2[3], vX[3] = {1,0,0};
3918
3919   Double_t carLVfullThick = fgkLVcardZ+fgkLVcardCuZ;
3920   AliITSv11GeomCableFlat cardLV("cardLV", fgkLVcardY, carLVfullThick); // name, width, thickness
3921   cardLV.SetNLayers(2);
3922   cardLV.SetLayer(0, fgkLVcardCuZ, copper,     30); // index, thickness, material, color
3923   cardLV.SetLayer(1, fgkLVcardZ,   glassFiber, 30);
3924   cardLV.SetInitialNode( (TGeoVolume *) fCardLVL);
3925   p1[0] = 0;
3926   p1[1] = fgkLVcardY/2;
3927   p1[2] = 0;
3928   p2[0] = fgkLVcardX;
3929   p2[1] = fgkLVcardY/2;
3930   p2[2] = 0;
3931   cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
3932   cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
3933   TGeoVolume* boxVol = cardLV.CreateAndInsertBoxCableSegment(1);
3934   TGeoRotation *rotAdd = new TGeoRotation("",90,0,0);
3935   TGeoCombiTrans *trCard = new TGeoCombiTrans(-fgkLVcardX/2,fgkLVcardY/2,0,rotAdd);
3936   fCardLVR->AddNode(boxVol, 1, trCard);
3937
3938   Double_t chip0fullThick = fgkLVChip0Z + fgkLVChip0SiZ;
3939   AliITSv11GeomCableFlat chipO("chipO", fgkLVChip0Y, chip0fullThick); // name, width, thickness
3940   chipO.SetNLayers(2);
3941   chipO.SetLayer(0, fgkLVChip0SiZ, siliconChip, 8); // index, thickness, material, color
3942   chipO.SetLayer(1, fgkLVChip0Z,   plastiChip, 12);
3943   chipO.SetInitialNode( (TGeoVolume *) fCardLVL);
3944   p1[0] = (fgkLVChip0PosX - fgkLVChip0X/2);
3945   p1[1] = fgkLVChip0PosY;
3946   p1[2] = carLVfullThick/2 + chip0fullThick/2;
3947
3948   p2[0] = (fgkLVChip0PosX + fgkLVChip0X/2);
3949   p2[1] = fgkLVChip0PosY;
3950   p2[2] = carLVfullThick/2 + chip0fullThick/2;
3951   chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
3952   chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
3953   boxVol = chipO.CreateAndInsertBoxCableSegment(1);
3954   trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
3955                                fgkLVChip0PosY,
3956                                carLVfullThick/2+chip0fullThick/2, rotAdd);
3957   fCardLVR->AddNode(boxVol, 1, trCard);
3958
3959   // put also this chip on the other side of the card
3960   trCard = new TGeoCombiTrans( fgkLVChip0PosX,
3961                                fgkLVChip0PosY,
3962                                -carLVfullThick/2-chip0fullThick/2, rotAdd);
3963   fCardLVL->AddNode(boxVol, 2, trCard);
3964   trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
3965                                fgkLVChip0PosY,
3966                                -carLVfullThick/2-chip0fullThick/2, rotAdd);
3967   fCardLVR->AddNode(boxVol, 2, trCard);
3968
3969   Double_t chip1fullThick = fgkLVChip1Z + fgkLVChip1SiZ;
3970   AliITSv11GeomCableFlat chip1("chip1", fgkLVChip1Y, chip1fullThick);
3971   chip1.SetNLayers(2);
3972   chip1.SetLayer(0, fgkLVChip1SiZ, siliconChip, 8);
3973   chip1.SetLayer(1, fgkLVChip1Z,   plastiChip, 12);
3974   chip1.SetInitialNode( (TGeoVolume *) fCardLVL);
3975   p1[0] = (fgkLVChip1PosX-fgkLVChip1X/2);
3976   p1[1] = fgkLVChip1PosY;
3977   p1[2] = carLVfullThick/2 + chip1fullThick/2;
3978
3979   p2[0] = (fgkLVChip1PosX+fgkLVChip1X/2);
3980   p2[1] = fgkLVChip1PosY;
3981   p2[2] = carLVfullThick/2 + chip1fullThick/2;
3982   chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
3983   chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
3984   boxVol = chip1.CreateAndInsertBoxCableSegment(1);
3985   trCard = new TGeoCombiTrans( -fgkLVChip1PosX,
3986                                fgkLVChip1PosY,
3987                                carLVfullThick/2 + chip1fullThick/2, rotAdd);
3988   fCardLVR->AddNode(boxVol, 1, trCard);
3989
3990   Double_t chip2fullThick = fgkLVChip2Z + fgkLVChip2SiZ;
3991   AliITSv11GeomCableFlat chip2("chip2", fgkLVChip2Y, chip2fullThick);
3992   chip2.SetNLayers(2);
3993   chip2.SetLayer(0, fgkLVChip2SiZ, siliconChip, 8);
3994   chip2.SetLayer(1, fgkLVChip2Z,   plastiChip, 12);
3995   chip2.SetInitialNode( (TGeoVolume *) fCardLVL);
3996   p1[0] = (fgkLVChip2PosX-fgkLVChip2X/2);
3997   p1[1] = fgkLVChip2PosY;
3998   p1[2] = carLVfullThick/2 + chip2fullThick/2;
3999   p2[0] = (fgkLVChip2PosX+fgkLVChip2X/2);
4000   p2[1] = fgkLVChip2PosY;
4001   p2[2] = carLVfullThick/2 + chip2fullThick/2;
4002   chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
4003   chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
4004   boxVol = chip2.CreateAndInsertBoxCableSegment(1);
4005   trCard = new TGeoCombiTrans( -fgkLVChip2PosX,
4006                                fgkLVChip2PosY,
4007                                carLVfullThick/2 + chip2fullThick/2, rotAdd);
4008   fCardLVR->AddNode(boxVol, 1, trCard);
4009
4010   Double_t chip3fullThick = fgkLVChip3Z + fgkLVChip3SiZ;
4011   AliITSv11GeomCableFlat chip3("chip3", fgkLVChip3Y, chip3fullThick);
4012   chip3.SetNLayers(2);
4013   chip3.SetLayer(0, fgkLVChip3Z,   plastiChip, 12);
4014   chip3.SetLayer(1, fgkLVChip3SiZ, siliconChip, 8);
4015   chip3.SetInitialNode( (TGeoVolume *) fCardLVL);
4016   p1[0] = (fgkLVChip3PosX-fgkLVChip3X/2);
4017   p1[1] = fgkLVChip3PosY;
4018   p1[2] = -carLVfullThick/2 - chip3fullThick/2;
4019   p2[0] = (fgkLVChip3PosX+fgkLVChip3X/2);
4020   p2[1] = fgkLVChip3PosY;
4021   p2[2] = -carLVfullThick/2 - chip3fullThick/2;
4022   chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
4023   chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
4024   boxVol = chip3.CreateAndInsertBoxCableSegment(1);
4025   trCard = new TGeoCombiTrans( -fgkLVChip3PosX,
4026                                fgkLVChip3PosY,
4027                                -carLVfullThick/2 - chip3fullThick/2, rotAdd);
4028   fCardLVR->AddNode(boxVol, 1, trCard);
4029
4030   // the Al pieces for heat exchange :
4031   TGeoBBox *alLVcooling1 = new TGeoBBox("alLVcooling1" ,
4032                            fgkLVcoolX1/2, fgkLVcoolY1/2, fgkLVcoolZ1/2);
4033
4034   TGeoTranslation *alLVcooling1Tr = new TGeoTranslation("alLVcooling1Tr",
4035                                         (fgkLVcoolX1/2+fgkLVcoolX2),
4036                                         fgkLVcoolPosY+fgkLVcoolY1/2,
4037                           carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
4038   TGeoTranslation *alLVcooling1TrB = new TGeoTranslation("alLVcooling1TrB",
4039                                          (fgkLVcoolX1/2+fgkLVcoolX2),
4040                                          fgkLVcoolPosY+fgkLVcoolY1/2,
4041                           -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
4042
4043   TGeoVolume *vAlLVcooling1 = new TGeoVolume("vAlLVcooling1",alLVcooling1,
4044                                              alCu12SDD);
4045   vAlLVcooling1->SetLineColor(2);
4046
4047   //--
4048   TGeoBBox * alLVcooling2 = new TGeoBBox("lLVcooling2" ,
4049                                  fgkLVcoolX2/2, fgkLVcoolY2/2, fgkLVcoolZ2/2);
4050   TGeoTranslation *alLVcooling2Tr = new TGeoTranslation("alLVcooling2Tr",
4051                                                         (fgkLVcoolX2/2),
4052                                         fgkLVcoolPosY+fgkLVcoolY1/2,
4053                      carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
4054   TGeoTranslation *alLVcooling2TrB = new TGeoTranslation("alLVcooling2TrB",
4055                                                          (fgkLVcoolX2/2),
4056                                         fgkLVcoolPosY+fgkLVcoolY1/2,
4057                    -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
4058
4059   TGeoVolume *vAlLVcooling2 = new TGeoVolume("vAlLVcooling2",alLVcooling2,
4060                                              alCu12SDD);
4061   vAlLVcooling2->SetLineColor(2);
4062
4063   //--
4064   Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4065                           +fgkLVcoolZ1*2.);
4066   TGeoBBox * alLVcooling3 = new TGeoBBox("lLVcooling3" ,
4067                            fgkLVcoolX3/2, fgkLVcoolY3/2, alLVcoolZ3/2);
4068   TGeoTranslation *alLVcooling3Tr = new TGeoTranslation("alLVcooling3Tr",
4069                                                         (-fgkLVcoolX3/2),
4070                                         fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
4071                                         0);
4072   TGeoVolume *vAlLVcooling3 = new TGeoVolume("vAlLVcooling3",alLVcooling3,alCu12SDD);
4073   vAlLVcooling3->SetLineColor(2);
4074
4075   //=== screw fixing th LV card to the U cooling tube :
4076   TGeoTube *littleScrew = new TGeoTube("littleScrewLV", 0, fgkLittleScrewR,
4077                                        fgkLVcoolY3/2);
4078   TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrewLV",
4079                                             littleScrew, stainless);
4080   TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
4081
4082   TGeoCombiTrans *cbScrew = new TGeoCombiTrans(0,0,fgkShiftLittleScrewLV,
4083                                                rotScrew);
4084   vAlLVcooling3->AddNode(vLittleScrew, 1, cbScrew);
4085
4086   TGeoTube *littleScrewHead = new TGeoTube("littleScrewLVhead",
4087                                            0, fgkLittleLVScrewHeadR,
4088                                            fgkLittleScrewHeadH/2);
4089   TGeoVolume *vLittleScrewHead = new TGeoVolume("vLittleScrewLVhead",
4090                                                 littleScrewHead, stainless);
4091   vLittleScrewHead->SetLineColor(kGray);
4092   TGeoCombiTrans *cbScrewHeadL = new TGeoCombiTrans( -fgkLVcoolX3/2,
4093                                                      fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
4094                                                      fgkShiftLittleScrewLV,
4095                                                      rotScrew);
4096   fCardLVL->AddNode(vLittleScrewHead, 1, cbScrewHeadL);
4097
4098   TGeoCombiTrans *cbScrewHeadR = new TGeoCombiTrans( fgkLVcoolX3/2,
4099                                                      fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
4100                                                      fgkShiftLittleScrewLV,
4101                                                      rotScrew);
4102   fCardLVR->AddNode(vLittleScrewHead, 1, cbScrewHeadR);
4103
4104   // adding the cooling pieces to the left card
4105   fCardLVL->AddNode(vAlLVcooling1, 1,alLVcooling1Tr);
4106   fCardLVL->AddNode(vAlLVcooling1, 2,alLVcooling1TrB);
4107   fCardLVL->AddNode(vAlLVcooling2, 1,alLVcooling2Tr);
4108   fCardLVL->AddNode(vAlLVcooling2, 2,alLVcooling2TrB);
4109   fCardLVL->AddNode(vAlLVcooling3, 1,alLVcooling3Tr);
4110
4111   TGeoTranslation *alLVcooling1TrR = new TGeoTranslation("alLVcooling1TrR",
4112                                          -(fgkLVcoolX1/2+fgkLVcoolX2),
4113                                          fgkLVcoolPosY+fgkLVcoolY1/2,
4114                                      carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
4115   TGeoTranslation *alLVcooling1TrBR = new TGeoTranslation("alLVcooling1TrBR",
4116                                           -(fgkLVcoolX1/2+fgkLVcoolX2),
4117                                           fgkLVcoolPosY+fgkLVcoolY1/2,
4118                                      -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
4119   TGeoTranslation *alLVcooling2TrR = new TGeoTranslation("alLVcooling2TrR",
4120                                                          -(fgkLVcoolX2/2),
4121                                          fgkLVcoolPosY+fgkLVcoolY1/2,
4122                      carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
4123   TGeoTranslation *alLVcooling2TrBR = new TGeoTranslation("alLVcooling2TrBR",
4124                                                           -(fgkLVcoolX2/2),
4125                                         fgkLVcoolPosY+fgkLVcoolY1/2,
4126                    -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
4127
4128   TGeoTranslation *alLVcooling3TrR = new TGeoTranslation("alLVcooling3TrR",
4129                                         fgkLVcoolX3/2,
4130                                         fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
4131                                         0);
4132   // and to the right card
4133   fCardLVR->AddNode(vAlLVcooling1, 1,alLVcooling1TrR);
4134   fCardLVR->AddNode(vAlLVcooling1, 2,alLVcooling1TrBR);
4135   fCardLVR->AddNode(vAlLVcooling2, 1,alLVcooling2TrR);
4136   fCardLVR->AddNode(vAlLVcooling2, 2,alLVcooling2TrBR);
4137   fCardLVR->AddNode(vAlLVcooling3, 1,alLVcooling3TrR);
4138
4139   return kTRUE;
4140 }
4141
4142 //________________________________________________________________________
4143 TGeoVolumeAssembly*  AliITSv11GeometrySDD::CreateHVCard(Int_t iLay){
4144   //
4145   // return an assembly containing the HV card
4146   //
4147   iLay = iLay;
4148
4149   TGeoMedium *ceramic          = GetMedium("CERAMICS$"); // ceramicHVcard
4150   TGeoMedium *medSMDcapaMiddle = GetMedium("SDD X7R capacitors$"); // check if different
4151   TGeoMedium *medSMDcapaEnd    = GetMedium("SDD X7R capacitors$"); // check if different
4152   TGeoMedium *stainless        = GetMedium("INOX$");       // ITSspdStainlesSteal ???????????
4153   TGeoMedium *plastic          = GetMedium("SDDKAPTON (POLYCH2)$");  // ITS_ITSsddKAPTON_POLYCH2 ???????????
4154   TGeoMedium *alCu12SDD       = GetMedium("ALCU12$"); // ITSsddAlCu12
4155
4156   TGeoVolumeAssembly *highVCard = new TGeoVolumeAssembly("ITSsddHVCard");
4157
4158   //====================================
4159   //--- the card itself
4160   TGeoBBox *ceramicCard = new TGeoBBox("ceramCard", fgkHVCardCeramX/2,
4161                                        fgkHVCardCeramY/2, fgkHVCardCeramZ/2);
4162   TGeoVolume *vCeramicCard = new TGeoVolume("vCeramCard", ceramicCard, ceramic);
4163   vCeramicCard->SetLineColor(38);// or 9 blue slightly dark
4164
4165   highVCard->AddNode(vCeramicCard, 1, 0);
4166
4167
4168   //====================================
4169   //--- capacitors
4170
4171   // capa1
4172   TGeoBBox *capa1Middle = new TGeoBBox("cardHVCapa1Middle", fgkHVCardCapa1X/2,
4173                                        fgkHVCardCapa1Ymid/2, fgkHVCardCapa1Z/2);
4174   TGeoVolume *vCapa1Middle = new TGeoVolume("vCardHVCapa1Middle",capa1Middle,
4175                                             medSMDcapaMiddle);
4176
4177   TGeoBBox *capa1End = new TGeoBBox("cardHVCapa1End", fgkHVCardCapa1X/2,
4178                                     fgkHVCardCapa1Yend/2, fgkHVCardCapa1Z/2);
4179   TGeoVolume *vCapa1End = new TGeoVolume("vCardHVCapa1End",capa1End,
4180                                          medSMDcapaEnd);
4181   vCapa1End->SetLineColor(18);// grey silver
4182   TGeoTranslation *capa1EndTr1 = new TGeoTranslation("cardHVcapa1EndTr1", 0,
4183                                      (fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0);
4184   TGeoTranslation *capa1EndTr2 = new TGeoTranslation("cardHVcapa1EndTr2", 0,
4185                                      -(fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0);
4186
4187   TGeoTranslation *capa1PosTr = new TGeoTranslation("cardHVcapa1PosTr",
4188                                     fgkHVCardCapa1PosX, fgkHVCardCapa1PosY,
4189                                     -fgkHVCardCeramZ/2-fgkHVCardCapa1Z/2);
4190
4191   TGeoVolumeAssembly *capa1  = new TGeoVolumeAssembly("cardHVCapa1");
4192   capa1->AddNode(vCapa1Middle, 1,0);
4193   capa1->AddNode(vCapa1End, 1, capa1EndTr1);
4194   capa1->AddNode(vCapa1End, 2, capa1EndTr2);
4195
4196   highVCard->AddNode(capa1, 1, capa1PosTr);
4197
4198   // capa2
4199   TGeoBBox *capa2Middle = new TGeoBBox("cardHVCapa2Middle", fgkHVCardCapa2X/2,
4200                                        fgkHVCardCapa2Ymid/2, fgkHVCardCapa2Z/2);
4201   TGeoVolume *vCapa2Middle = new TGeoVolume("vCardHVCapa2Middle",capa2Middle,
4202                                             medSMDcapaMiddle);
4203
4204   TGeoBBox *capa2End = new TGeoBBox("cardHVCapa2End", fgkHVCardCapa2X/2,
4205                                     fgkHVCardCapa2Yend/2, fgkHVCardCapa2Z/2);
4206   TGeoVolume *vCapa2End = new TGeoVolume("vCardHVCapa2End",capa2End,
4207                                          medSMDcapaEnd);
4208   vCapa2End->SetLineColor(18);// grey silver
4209   TGeoTranslation *capa2EndTr1 = new TGeoTranslation("cardHVcapa2EndTr1", 0,
4210                                      (fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0);
4211   TGeoTranslation *capa2EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2", 0,
4212                                      -(fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0);
4213
4214   TGeoTranslation *capa2PosTr = new TGeoTranslation("cardHVcapa2PosTr",
4215                                     fgkHVCardCapa2PosX, fgkHVCardCapa2PosY,
4216                                     -fgkHVCardCeramZ/2-fgkHVCardCapa2Z/2);
4217
4218   TGeoVolumeAssembly *capa2  = new TGeoVolumeAssembly("cardHVCapa2");
4219   capa2->AddNode(vCapa2Middle, 1,0);
4220   capa2->AddNode(vCapa2End, 1, capa2EndTr1);
4221   capa2->AddNode(vCapa2End, 2, capa2EndTr2);
4222
4223   highVCard->AddNode(capa2, 1, capa2PosTr);
4224
4225   // capa3
4226   TGeoBBox *capa3Middle = new TGeoBBox("cardHVCapa3Middle", fgkHVCardCapa3Xmid/2,
4227                                        fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2);
4228   TGeoVolume *vCapa3Middle = new TGeoVolume("vCardHVCapa3Middle",capa3Middle,
4229                                             medSMDcapaMiddle);
4230
4231   TGeoBBox *capa3End = new TGeoBBox("cardHVCapa3End", fgkHVCardCapa3Xend/2,
4232                                     fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2);
4233   TGeoVolume *vCapa3End = new TGeoVolume("vCardHVCapa3End",capa3End,
4234                                          medSMDcapaEnd);
4235   vCapa3End->SetLineColor(18);// grey silver
4236
4237   TGeoTranslation *capa3EndTr1 = new TGeoTranslation("cardHVcapa3EndTr1",
4238                                  (fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0);
4239   TGeoTranslation *capa3EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2",
4240                                  -(fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0);
4241
4242   TGeoVolumeAssembly *capa3  = new TGeoVolumeAssembly("cardHVCapa3");
4243   capa3->AddNode(vCapa3Middle, 1,0);
4244   capa3->AddNode(vCapa3End, 1, capa3EndTr1);
4245   capa3->AddNode(vCapa3End, 2, capa3EndTr2);
4246
4247   TGeoTranslation *capa3PosTr1 = new TGeoTranslation("cardHVcapa3PosTr1",
4248                                     fgkHVCardCapa3PosX1, fgkHVCardCapa3PosY1,
4249                                     -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4250
4251   TGeoTranslation *capa3PosTr2 = new TGeoTranslation("cardHVcapa3PosTr2",
4252                                     fgkHVCardCapa3PosX2, fgkHVCardCapa3PosY1,
4253                                     -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4254
4255   TGeoTranslation *capa3PosTr3 = new TGeoTranslation("cardHVcapa3PosTr3",
4256                                     fgkHVCardCapa3PosX3, fgkHVCardCapa3PosY2,
4257                                     -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4258
4259   TGeoTranslation *capa3PosTr4 = new TGeoTranslation("cardHVcapa3PosTr4",
4260                                     fgkHVCardCapa3PosX4, fgkHVCardCapa3PosY2,
4261                                     -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4262
4263   TGeoTranslation *capa3PosTr5 = new TGeoTranslation("cardHVcapa3PosTr5",
4264                                     fgkHVCardCapa3PosX5, fgkHVCardCapa3PosY3,
4265                                     -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4266
4267   highVCard->AddNode(capa3, 1, capa3PosTr1);
4268   highVCard->AddNode(capa3, 2, capa3PosTr2);
4269   highVCard->AddNode(capa3, 3, capa3PosTr3);
4270   highVCard->AddNode(capa3, 4, capa3PosTr4);
4271   highVCard->AddNode(capa3, 5, capa3PosTr5);
4272
4273   //====================================
4274   //--- connexions to LV card
4275
4276   Double_t fgkConnexLVHVdiam1 =  0.8*fgkmm;
4277   Double_t fgkConnexLVHVdiam2 =  2*fgkmm;
4278   Double_t fgkConnexLVHVlen   =  6.2*fgkmm;
4279   Double_t fgkConnexLVHVx     =  3*fgkmm;
4280   Double_t fgkConnexLVHVy1    =  8*fgkmm;
4281   Double_t fgkConnexLVHVdy    =  2.5*fgkmm;
4282
4283   TGeoTube *connexLVHVmetal = new TGeoTube("connexLVHVmetal",0,
4284                                   fgkConnexLVHVdiam1/2,fgkConnexLVHVlen/2);
4285   TGeoTube *connexLVHVplastic = new TGeoTube("connexLVHVplastic",
4286                                              fgkConnexLVHVdiam1/2,
4287                                              fgkConnexLVHVdiam2/2,
4288                                              fgkConnexLVHVlen/2);
4289   TGeoVolume *vConnexLVHVmetal = new TGeoVolume("ITSsddConnexLVHVmetal",
4290                                                 connexLVHVmetal, stainless);
4291   TGeoVolume *vConnexLVHVplast = new TGeoVolume("ITSsddConnexLVHVplast",
4292                                                 connexLVHVplastic, plastic);
4293   vConnexLVHVmetal->SetLineColor(10);// white
4294   vConnexLVHVplast->SetLineColor(12);  // dark grey
4295
4296   TGeoVolumeAssembly *connexion = new TGeoVolumeAssembly("ITSsddConnexLVHV");
4297   connexion->AddNode(vConnexLVHVmetal, 1, 0);
4298   connexion->AddNode(vConnexLVHVplast, 1, 0);
4299
4300   TGeoTranslation *trConnexion1 = new TGeoTranslation(-fgkConnexLVHVx,fgkConnexLVHVy1,
4301                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4302   TGeoTranslation *trConnexion2 = new TGeoTranslation( fgkConnexLVHVx,fgkConnexLVHVy1,
4303                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4304
4305   TGeoTranslation *trConnexion3 = new TGeoTranslation(-fgkConnexLVHVx,
4306                                         fgkConnexLVHVy1+fgkConnexLVHVdy,
4307                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4308   TGeoTranslation *trConnexion4 = new TGeoTranslation( fgkConnexLVHVx,
4309                                         fgkConnexLVHVy1+fgkConnexLVHVdy,
4310                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4311
4312   TGeoTranslation *trConnexion5 = new TGeoTranslation(-fgkConnexLVHVx,
4313                                         fgkConnexLVHVy1+2*fgkConnexLVHVdy,
4314                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4315   TGeoTranslation *trConnexion6 = new TGeoTranslation( fgkConnexLVHVx,
4316                                         fgkConnexLVHVy1+2*fgkConnexLVHVdy,
4317                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4318
4319   TGeoTranslation *trConnexion7 = new TGeoTranslation(-fgkConnexLVHVx,
4320                                         fgkConnexLVHVy1+3*fgkConnexLVHVdy,
4321                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4322   TGeoTranslation *trConnexion8 = new TGeoTranslation( fgkConnexLVHVx,
4323                                         fgkConnexLVHVy1+3*fgkConnexLVHVdy,
4324                                        -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4325
4326   highVCard->AddNode(connexion, 1, trConnexion1);
4327   highVCard->AddNode(connexion, 2, trConnexion2);
4328   highVCard->AddNode(connexion, 3, trConnexion3);
4329   highVCard->AddNode(connexion, 4, trConnexion4);
4330   highVCard->AddNode(connexion, 5, trConnexion5);
4331   highVCard->AddNode(connexion, 6, trConnexion6);
4332   highVCard->AddNode(connexion, 7, trConnexion7);
4333   highVCard->AddNode(connexion, 8, trConnexion8);
4334
4335   //====================================
4336   //--- cooling pieces
4337
4338   TGeoBBox *cardHVcool1 = new TGeoBBox("cardHVcool1",fgkHVCardCool1X/2,
4339                                        fgkHVCardCool1Y/2, fgkHVCardCool1Z/2);
4340
4341
4342   TGeoBBox *cardHVcool2 = new TGeoBBox("cardHVcool2",fgkHVCardCool2X/2,
4343                                        fgkHVCardCool2Y/2, fgkHVCardCool2Z/2);
4344
4345   TGeoBBox *cardHVcool3 = new TGeoBBox("cardHVcool3",fgkHVCardCool3X/2,
4346                                        fgkHVCardCool3Y/2, fgkHVCardCool3Z/2);
4347
4348   TGeoVolume *vCardHVcool1 = new TGeoVolume("vCardHVcool1",cardHVcool1,
4349                                             alCu12SDD);
4350   TGeoVolume *vCardHVcool2 = new TGeoVolume("vCardHVcool2",cardHVcool2,
4351                                             alCu12SDD);
4352   TGeoVolume *vCardHVcool3 = new TGeoVolume("vCardHVcool3",cardHVcool3,
4353                                             alCu12SDD);
4354   // This last volume contains the screw used for fixing
4355   // the card to the cooling tube ...
4356   TGeoTube *littleScrewHV = new TGeoTube("littleScrewHV", 0, fgkLittleScrewR,
4357                                          fgkHVCardCool3Y/2);
4358   TGeoVolume *vLittleScrewHV = new TGeoVolume("vLittleScrewHV",
4359                                               littleScrewHV, stainless);
4360
4361   TGeoRotation *rotScrewHead = new TGeoRotation("",0,90,0);
4362   vCardHVcool3->AddNode(vLittleScrewHV, 1,rotScrewHead);
4363
4364   vCardHVcool1->SetLineColor(2); //red
4365   vCardHVcool2->SetLineColor(2); //red
4366   vCardHVcool3->SetLineColor(2); //red
4367
4368   TGeoTranslation *cool1Tr1 = new TGeoTranslation("cardHVcool1Tr1",
4369                                              fgkHVCardCeramX/2-fgkHVCardCool1X/2,
4370                                              -fgkHVCardCoolDY+fgkHVCardCool1Y/2,
4371                                              fgkHVCardCeramZ/2+fgkHVCardCool1Z/2);
4372   TGeoTranslation *cool1Tr2 = new TGeoTranslation("cardHVcool1Tr2",
4373                                             -fgkHVCardCeramX/2+fgkHVCardCool1X/2,
4374                                              -fgkHVCardCoolDY+fgkHVCardCool1Y/2,
4375                                              fgkHVCardCeramZ/2+fgkHVCardCool1Z/2);
4376
4377   highVCard->AddNode(vCardHVcool1, 1, cool1Tr1);
4378   highVCard->AddNode(vCardHVcool1, 2, cool1Tr2);
4379
4380   TGeoTranslation *cool2Tr1 = new TGeoTranslation("cardHVcool2Tr1",
4381                                   fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X/2,
4382                                              -fgkHVCardCoolDY-fgkHVCardCool2Y/2,
4383                                              fgkHVCardCeramZ/2+fgkHVCardCool2Z/2);
4384
4385   TGeoTranslation *cool2Tr2 = new TGeoTranslation("cardHVcool2Tr2",
4386                                  -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X/2,
4387                                              -fgkHVCardCoolDY-fgkHVCardCool2Y/2,
4388                                              fgkHVCardCeramZ/2+fgkHVCardCool2Z/2);
4389
4390   highVCard->AddNode(vCardHVcool2, 1, cool2Tr1);
4391   highVCard->AddNode(vCardHVcool2, 2, cool2Tr2);
4392
4393   TGeoTranslation *cool3Tr1 = new TGeoTranslation("cardHVcool2Tr1",
4394                  fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2,
4395                                              -fgkHVCardCoolDY-fgkHVCardCool3Y/2,
4396                                  fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2);
4397
4398   TGeoTranslation *cool3Tr2 = new TGeoTranslation("cardHVcool2Tr2",
4399                 -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2,
4400                                              -fgkHVCardCoolDY-fgkHVCardCool3Y/2,
4401                                  fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2);
4402
4403   highVCard->AddNode(vCardHVcool3, 1, cool3Tr1);
4404   highVCard->AddNode(vCardHVcool3, 2, cool3Tr2);
4405
4406   //====================================
4407   //--- screws
4408   TGeoCombiTrans *cbScrewHead1 = new TGeoCombiTrans("cardHVscrewHeadTr1",
4409                  fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2,
4410                                  -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
4411                                  fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
4412                                                     rotScrewHead);
4413   TGeoCombiTrans *cbScrewHead2 = new TGeoCombiTrans("cardHVscrewHeadTr2",
4414                 -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2,
4415                                  -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
4416                                  fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
4417                                                     rotScrewHead);
4418
4419   highVCard->AddNode(fCommonVol[0], 1, cbScrewHead1);
4420   highVCard->AddNode(fCommonVol[0], 2, cbScrewHead2);
4421
4422   return highVCard;
4423 }
4424
4425
4426 //________________________________________________________________________
4427 TGeoVolumeAssembly*  AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) {
4428 //
4429 // return an assembly containing the LV, HV and Carlos cards of one ladder
4430 // and their cooling system
4431 //
4432
4433   TGeoMedium *alCu12SDD       = GetMedium("ALCU12$"); // ITSsddAlCu12
4434   TGeoMedium *phynoxSDD       = GetMedium("INOX$");
4435   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
4436
4437   TGeoVolumeAssembly *endLadderCards = new TGeoVolumeAssembly("endLadderCards");
4438
4439   //=*********************************
4440   //--- The rounded pipe for the end ladder card coooling
4441
4442   Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
4443   Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3;
4444   Int_t    nCards = 3;
4445
4446   if (iLay==4) {
4447     endLadPipeUlength = fgkEndLadPipeUlengthLay4;
4448     endLadPipeArmZ = fgkEndLadPipeArmZLay4;
4449     nCards = 4;
4450   }
4451
4452   AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
4453   endLadderPipe.SetNLayers(2);
4454   endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
4455   endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
4456
4457   Double_t coolUzPos = fgkEndLadPipeOuterDiam/2+2.*fgkmm; //it is the x coord of the axis
4458   // of the U colling pipe in its center
4459
4460   Double_t coordA[3] = { fgkEndLadPipeUwidth/2, 0, endLadPipeUlength+coolUzPos};
4461   Double_t vectA[3]  = {0,0,1};
4462
4463   Double_t coordB[3] = { fgkEndLadPipeUwidth/2,0, fgkEndLadPipeRadius+coolUzPos};
4464   Double_t vectB[3]  = {0,0,1};
4465
4466   Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, 0, coolUzPos};
4467   Double_t vectC[3]  = {1,0,0};
4468
4469   Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, 0, coolUzPos};
4470   Double_t vectD[3]  = {-1,0,0};
4471
4472   Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, 0, fgkEndLadPipeRadius+coolUzPos};
4473   Double_t vectE[3]  = {0,0,-1};
4474
4475   Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,0, endLadPipeUlength+coolUzPos};
4476   Double_t vectF[3]  = {0,0,-1};
4477
4478   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
4479   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
4480   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
4481   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
4482   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
4483   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
4484
4485   endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
4486   //endLadderPipe.CreateAndInsertCableSegment( 1);
4487   endLadderPipe.CreateAndInsertTubeSegment( 1);
4488   //endLadderPipe.CreateAndInsertCableSegment( 2);
4489   endLadderPipe.CreateAndInsertTorusSegment( 2);
4490   //endLadderPipe.CreateAndInsertCableSegment( 3);
4491   endLadderPipe.CreateAndInsertTubeSegment( 3);
4492   //endLadderPipe.CreateAndInsertCableSegment( 4);
4493   endLadderPipe.CreateAndInsertTorusSegment( 4);
4494   //endLadderPipe.CreateAndInsertCableSegment( 5);
4495   endLadderPipe.CreateAndInsertTubeSegment( 5);
4496
4497   TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
4498                                          fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
4499   TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
4500                                     fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
4501
4502   TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
4503                                                             - fgkEndLadPipeArmBoxDX,
4504                                                              fgkEndLadPipeArmBoxDY,0);
4505   TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
4506                                                             fgkEndLadPipeArmBoxDX,
4507                                                             fgkEndLadPipeArmBoxDY,0);
4508   endLadPipeArmBoxDY1->RegisterYourself();
4509   endLadPipeArmBoxDY2->RegisterYourself();
4510
4511   if(GetDebug(3)) { // Remove compiler warning.
4512     endLadPipeArmBox->InspectShape();
4513     endLadPipeArmTube->InspectShape();
4514   }
4515
4516   TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
4517                                            "endLadPipeArmBox:endLadPipeArmBoxDY1"
4518                                            "- endLadPipeArmTube");
4519   TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
4520                                            "endLadPipeArmBox:endLadPipeArmBoxDY2"
4521                                            "- endLadPipeArmTube");
4522
4523   TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
4524                                                endLadPipeArm1, alCu12SDD);
4525   TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
4526                                                endLadPipeArm2, alCu12SDD);
4527   vEndLadPipeArm1->SetLineColor(2);
4528   vEndLadPipeArm2->SetLineColor(2);
4529
4530   Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
4531                    +fgkEndLadPipeArmZpos);
4532
4533   TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
4534                                           -fgkEndLadPipeUwidth/2,0,armZ);
4535   TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
4536                                            fgkEndLadPipeUwidth/2,0,armZ);
4537
4538   endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
4539   endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
4540
4541   //=*********************************
4542   //--- LV cards
4543   TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
4544   TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
4545
4546   Double_t spaceBetweenCards = 0.2*fgkmm;
4547
4548   Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
4549                            +fgkEndLadPipeArmBoxDX);
4550   Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
4551                            +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
4552
4553   Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4554                           +fgkLVcoolZ1*2.);
4555
4556   Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
4557                           +coolUzPos+1.25*fgkmm;
4558   // Position in z of the first LVB with respect to the start of the cooling
4559   // rectangular arm, coming  (from inside of the ladder)
4560   // The cards are added one after the other
4561
4562   for (Int_t iCard=0; iCard<nCards; iCard++) {
4563
4564     Double_t cardLVzShift = firstLVCardZ +
4565       Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
4566
4567     TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
4568                                              cardLVyShift, cardLVzShift);
4569     TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
4570                                              cardLVyShift, cardLVzShift);
4571
4572     endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
4573     endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
4574   }
4575
4576   //=*********************************
4577   //--- HV cards
4578   TGeoVolumeAssembly *cardHV = fCardHV;
4579
4580   Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
4581                        + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
4582
4583   Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
4584                                 -(fgkHVCardCeramZ)/2);
4585
4586   for (Int_t iCard=0; iCard<nCards; iCard++) {
4587
4588     Double_t fact = iCard*2.+1.;
4589     Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
4590                          + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
4591     TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy, coolHVdz);
4592     endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
4593   }
4594
4595   //=*********************************
4596   //--- Carlos card
4597
4598   TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
4599 //   TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
4600 //                                               0, -fgkCarlosSuppAngle, 0);
4601
4602   Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
4603   Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
4604                                fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
4605   // position in z of the first Carlos board, coming  from inside of the ladder
4606
4607   Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 +
4608                            fgkEndLadPipeArmBoxDY);
4609
4610   for (Int_t iCard=0; iCard<nCards; iCard++) {
4611
4612     Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
4613                             iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
4614     TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy,carloszPos,
4615                                                    (TGeoRotation*) fCommonTr[0]);
4616
4617     endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
4618   }
4619
4620   return endLadderCards;
4621 }
4622
4623
4624 //________________________________________________________________________
4625 TGeoVolume*  AliITSv11GeometrySDD::CreateEndLadderCardsV(Int_t iLay) {
4626 //
4627 // return an Pcon containing the LV, HV and Carlos cards of one ladder
4628 // and their cooling system
4629 // This is the code actually used for the end ladder cards
4630 //
4631
4632   TGeoMedium *alCu12SDD       = GetMedium("ALCU12$"); // ITSsddAlCu12
4633   TGeoMedium *phynoxSDD       = GetMedium("INOX$");
4634   TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
4635   TGeoMedium *copper          = GetMedium("COPPER$");
4636   TGeoMedium *plastic         = GetMedium("SDDKAPTON (POLYCH2)$");  // ???
4637   TGeoMedium *airSDD          = GetMedium("SDD AIR$");
4638   TGeoMedium *opticalFiber    = GetMedium("SDD OPTICFIB$");
4639   TGeoMedium *polyurethane    = GetMedium("POLYURETHANE$");
4640
4641   Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
4642   Double_t endLadPipeArmZ    = fgkEndLadPipeArmZLay3;
4643   Int_t    nCards = 3;
4644   Double_t rREF   = fgkEndLaddCardsShortRadiusLay3;
4645   Double_t deltaZcables = 0;
4646   // reference radius corresponding to local y=0
4647
4648   if (iLay==4) {
4649     endLadPipeUlength = fgkEndLadPipeUlengthLay4;
4650     endLadPipeArmZ = fgkEndLadPipeArmZLay4;
4651     nCards = 4;
4652     rREF = fgkEndLaddCardsShortRadiusLay4;
4653     deltaZcables = 2.8*fgkmm;
4654   }
4655
4656   Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
4657                            +fgkEndLadPipeArmBoxDX);
4658   Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
4659                            +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
4660
4661   Double_t rMin   = rREF + cardLVyShift;
4662   // (The LV card is defining rMin because it is the lower object)
4663
4664   Double_t thickTotCable = 0.5;
4665
4666   //==================================
4667   //--- The Pcon container
4668
4669   // minimum angle of the Pcon :
4670   Double_t tanDPhi = ((fgkEndLadPipeUwidth/2+fgkEndLadPipeArmX/2) /
4671                      (rREF-fgkEndLadPipeArmY/2) );
4672   Double_t dphi = 2*TMath::ATan(tanDPhi)*TMath::RadToDeg();
4673   Double_t phi0 = 90-dphi/2;
4674   Double_t coolUzPos = fgkEndLadPipeOuterDiam/2 + fgkDistEndLaddCardsLadd; // it is the z coord of the axis
4675                                                         // of the U colling pipe in its center
4676   Double_t zMax = endLadPipeUlength+coolUzPos;
4677   Double_t rMax = rMin + fgkLVcardY;
4678   rMax = TMath::Sqrt(rMax*rMax + cardLVxShift*cardLVxShift);
4679   Double_t cablesRadius  = rMax-0.5;
4680
4681   TGeoPcon *containerShape = new TGeoPcon("EndLadderCcontainerShape", phi0, dphi, 10);
4682    //DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
4683   // hard coded numbers are fine tuning to avoid overlaps with other volume in the old geometry
4684   containerShape->DefineSection(0, fgkDistEndLaddCardsLadd, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
4685   containerShape->DefineSection(1, fgkDistEndLaddCardsLadd+1.4, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
4686   containerShape->DefineSection(2,  fgkDistEndLaddCardsLadd+1.4, rMin, rMax);
4687   containerShape->DefineSection(3,  endLadPipeArmZ+2*fgkEndLadPipeRadius, rMin, rMax);
4688   containerShape->DefineSection(4,  endLadPipeArmZ+2*fgkEndLadPipeRadius, rREF-1.*fgkmm, rMax);
4689   containerShape->DefineSection(5,  zMax, rREF-1.*fgkmm, rMax);
4690   // the following is quite dirty but works for the moment ...
4691   containerShape->DefineSection(6,  zMax,  rREF+fgkCarlosCardZ1/2, rMax);
4692   containerShape->DefineSection(7, zMax+1, cablesRadius-thickTotCable/2, rMax);
4693
4694   // The next parameters define the shape of the Pcon at its end and where cables
4695   // are escaping...
4696   Double_t cableSectionR1 = cablesRadius-thickTotCable/2;
4697   Double_t cableSectionR2 = rMax;
4698   Double_t cableSectionZ1 = zMax + 23.6*fgkmm + 3.0*fgkcm + deltaZcables;
4699   Double_t cableSectionZ2 = zMax + 23.6*fgkmm + 4.0*fgkcm + deltaZcables;
4700   // Those numbers are to be fixed to stick the maximum to the SDD cone
4701   // (hardcoded numbers are ugly, but it's easier to find where to stop)
4702
4703   containerShape->DefineSection(8, cableSectionZ1, cableSectionR1, rMax);
4704   containerShape->DefineSection(9, cableSectionZ2, cableSectionR2, rMax);
4705
4706   TGeoVolume *endLadderCards = new TGeoVolume("endLadderCards",containerShape,airSDD);
4707   //endLadderCards->SetVisibility(kFALSE);
4708
4709   //=*********************************
4710   //--- The rounded pipe for the end ladder card cooling
4711
4712   AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
4713   endLadderPipe.SetNLayers(2);
4714   endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
4715   endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
4716
4717   Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos};
4718   Double_t vectA[3]  = {0,0,1};
4719
4720   Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos};
4721   Double_t vectB[3]  = {0,0,1};
4722
4723   Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, rREF, coolUzPos};
4724   Double_t vectC[3]  = {1,0,0};
4725
4726   Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, rREF, coolUzPos};
4727   Double_t vectD[3]  = {-1,0,0};
4728
4729   Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, rREF, fgkEndLadPipeRadius+coolUzPos};
4730   Double_t vectE[3]  = {0,0,-1};
4731
4732   Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,rREF, endLadPipeUlength+coolUzPos};
4733   Double_t vectF[3]  = {0,0,-1};
4734
4735   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
4736   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
4737   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
4738   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
4739   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
4740   endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
4741
4742   endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
4743   //endLadderPipe.CreateAndInsertCableSegment( 1);
4744   endLadderPipe.CreateAndInsertTubeSegment( 1);
4745   //endLadderPipe.CreateAndInsertCableSegment( 2);
4746   endLadderPipe.CreateAndInsertTorusSegment( 2);
4747   //endLadderPipe.CreateAndInsertCableSegment( 3);
4748   endLadderPipe.CreateAndInsertTubeSegment( 3);
4749   //endLadderPipe.CreateAndInsertCableSegment( 4);
4750   endLadderPipe.CreateAndInsertTorusSegment( 4);
4751   //endLadderPipe.CreateAndInsertCableSegment( 5);
4752   endLadderPipe.CreateAndInsertTubeSegment( 5);
4753
4754   TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
4755                                          fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
4756   TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
4757                                     fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
4758
4759   TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
4760                                                             - fgkEndLadPipeArmBoxDX,
4761                                                              fgkEndLadPipeArmBoxDY,0);
4762   TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
4763                                                             fgkEndLadPipeArmBoxDX,
4764                                                             fgkEndLadPipeArmBoxDY,0);
4765   endLadPipeArmBoxDY1->RegisterYourself();
4766   endLadPipeArmBoxDY2->RegisterYourself();
4767
4768   if(GetDebug(3)) { // Remove compiler warning.
4769     endLadPipeArmBox->InspectShape();
4770     endLadPipeArmTube->InspectShape();
4771   }
4772
4773   TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
4774                                            "endLadPipeArmBox:endLadPipeArmBoxDY1"
4775                                            "- endLadPipeArmTube");
4776   TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
4777                                            "endLadPipeArmBox:endLadPipeArmBoxDY2"
4778                                            "- endLadPipeArmTube");
4779
4780   TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
4781                                                endLadPipeArm1, alCu12SDD);
4782   TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
4783                                                endLadPipeArm2, alCu12SDD);
4784   vEndLadPipeArm1->SetLineColor(2);
4785   vEndLadPipeArm2->SetLineColor(2);
4786
4787   Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
4788                    +fgkEndLadPipeArmZpos);
4789
4790   TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
4791                                           -fgkEndLadPipeUwidth/2,rREF,armZ);
4792   TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
4793                                            fgkEndLadPipeUwidth/2,rREF,armZ);
4794
4795   endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
4796   endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
4797
4798   //=*********************************
4799   //--- LV cards
4800   TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
4801   TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
4802
4803   Double_t spaceBetweenCards = 0.2*fgkmm;
4804
4805
4806   Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4807                           +fgkLVcoolZ1*2.);
4808
4809   Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
4810                           +coolUzPos+1.25*fgkmm;
4811   // Position in z of the first LVB with respect to the start of the cooling
4812   // rectangular arm, coming  (from inside of the ladder)
4813   // The cards are added one after the other
4814
4815   for (Int_t iCard=0; iCard<nCards; iCard++) {
4816
4817     Double_t cardLVzShift = firstLVCardZ +
4818       Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
4819
4820     TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
4821                                              cardLVyShift+rREF, cardLVzShift);
4822     TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
4823                                              cardLVyShift+rREF, cardLVzShift);
4824
4825     endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
4826     endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
4827   }
4828
4829   //=*********************************
4830   //--- HV cards
4831   TGeoVolumeAssembly *cardHV = fCardHV;
4832
4833   Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
4834                        + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
4835   // shift of the HV card in local y w.r.t the local y=0 (center of cooling tube)
4836
4837   Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
4838                                 -(fgkHVCardCeramZ)/2);
4839
4840   for (Int_t iCard=0; iCard<nCards; iCard++) {
4841
4842     Double_t fact = iCard*2.+1.;
4843     Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
4844                          + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
4845     TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy+rREF, coolHVdz);
4846     endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
4847   }
4848
4849   //=*********************************
4850   //--- Carlos card
4851
4852   TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
4853 //   TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
4854 //                                               0, -fgkCarlosSuppAngle, 0);
4855
4856   Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
4857   Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
4858                                fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
4859   // position in z of the first Carlos board, coming  from inside of the ladder
4860
4861   Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 +
4862                            fgkEndLadPipeArmBoxDY);
4863
4864   for (Int_t iCard=0; iCard<nCards; iCard++) {
4865
4866     Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
4867                             iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
4868     TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy+rREF,carloszPos,
4869                                                    (TGeoRotation*) fCommonTr[0]);
4870
4871     endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
4872   }
4873
4874
4875   //=*********************************
4876   //--- Cables
4877
4878
4879   Double_t sectionV   = (fgkSectionCuPerMod+fgkSectionPlastPerMod
4880                          + fgkSectionGlassPerMod)*nCards
4881                          + fgkSectionCoolPolyuEL + fgkSectionCoolWaterEL;
4882   // We fix thickness, then width is calculated accordingly
4883   Double_t width      = sectionV/thickTotCable;
4884   Double_t thickCu    = thickTotCable*fgkSectionCuPerMod
4885             / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4886   Double_t thickPlast = thickTotCable*fgkSectionPlastPerMod
4887             / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4888   Double_t thickGlass = thickTotCable*fgkSectionGlassPerMod
4889             / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4890
4891   Double_t thickCoolPolyu = thickTotCable*fgkSectionCoolPolyuEL
4892             / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4893   Double_t thickCoolWater = thickTotCable*fgkSectionCoolWaterEL
4894             / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4895
4896   AliITSv11GeomCableFlat cable("SDDcableEndLadder",width,thickTotCable);
4897   cable.SetNLayers(5);
4898   cable.SetLayer(0, thickCu, copper, kRed);
4899   cable.SetLayer(1, thickPlast, plastic, kYellow);
4900   cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
4901   cable.SetLayer(3, thickCoolPolyu, polyurethane, kGray);
4902   cable.SetLayer(4, thickCoolWater, coolerMediumSDD, kBlue);
4903
4904   Double_t zVect[3]={0,0,1};
4905   Double_t xMinCable = firstCarlosCardZ+nCards*(fgkCarlosSuppZ3
4906                        +spaceBetweenCarlsoCards)/2 + 2.9;
4907   // the 2.9cm is for taking into account carlos card angle...
4908
4909   Double_t zEndCable = GetConeZ(cablesRadius-thickTotCable/2, cableSectionR1,
4910                                 cableSectionR2,cableSectionZ1,cableSectionZ2);
4911
4912   Double_t pos1[3] = {0, cablesRadius, xMinCable};
4913   Double_t pos2[3] = {0, cablesRadius, zEndCable};
4914   cable.AddCheckPoint( endLadderCards, 0, pos1, zVect );
4915   cable.AddCheckPoint( endLadderCards, 1, pos2, zVect );
4916   cable.SetInitialNode(endLadderCards);
4917   cable.CreateAndInsertCableSegment(1);
4918
4919   // The earth cable
4920   TGeoTorus *earthShape = new TGeoTorus(rMax-fgkEndLadderEarthCableR,
4921                                         0., fgkEndLadderEarthCableR,
4922                                         phi0, dphi); // same as containerShape
4923
4924   TGeoVolume *earthCable = new TGeoVolume("SDDcableEndLadderEarthCable",
4925                                           earthShape, copper);
4926
4927   endLadderCards->AddNode(earthCable, 1,
4928                         new TGeoTranslation(0, 0, fgkDistEndLaddCardsLadd+1));
4929
4930   return endLadderCards;
4931 }
4932
4933 //________________________________________________________________________
4934 TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateSupportRing(Int_t iLay) {
4935 //
4936 // return an assembly of the support rings, attaching the ladders to the cone
4937 //
4938
4939
4940   iLay = iLay;
4941
4942   TGeoMedium *stainless = GetMedium("INOX$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
4943   TGeoVolumeAssembly *supportRing = new TGeoVolumeAssembly("supportRing");
4944
4945
4946   //**********************************
4947   // ruby cage
4948
4949   Double_t fgkRubyCageX          = 9*fgkmm;
4950   Double_t fgkRubyCageY          = 5.5*fgkmm;
4951   Double_t fgkRubyCageZ          = 8*fgkmm;
4952   Double_t fgkRubyCageInternSide = 5.*fgkmm; //side of the internal square
4953   Double_t fgkRubyCageHoleDX     = 2.*fgkmm;
4954   Double_t fgkRubyCageVIntern    = 5.42*fgkmm;
4955   Double_t fgkRubyCageScrewHoleR = 4.5/2*fgkmm;
4956   Double_t fgkRubyCageScrewHoleY = 1.5*fgkmm;
4957
4958   TGeoBBox *rubyCageBox = new TGeoBBox("rubyCageBox",fgkRubyCageX/2,fgkRubyCageY/2,
4959                                        fgkRubyCageZ/2);
4960
4961   Double_t epsilon = 1e-10; //dummy epsilon to force the gl viewer to show holes
4962
4963   // pieces common to both square and V cages
4964   TGeoBBox *rubyCageInternBox = new TGeoBBox("rubyCageInternBox",fgkRubyCageInternSide/2,
4965                                     fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2);
4966
4967   TGeoTube *screwHole = new TGeoTube("screwHole", 0, fgkRubyCageScrewHoleR,
4968                                      fgkRubyCageHoleDX/2+epsilon);
4969
4970   TGeoRotation *rotV = new TGeoRotation("", 90,90,-90);
4971   TGeoCombiTrans *trScrewHole = new TGeoCombiTrans("trScrewHole",
4972                                     fgkRubyCageX/2-fgkRubyCageHoleDX/2,
4973                                    -fgkRubyCageY/2+fgkRubyCageScrewHoleY,0,rotV);
4974   trScrewHole->RegisterYourself();
4975
4976   TGeoBBox *screwHoleFoot = new TGeoBBox("screwHoleFoot",fgkRubyCageHoleDX/2+epsilon,
4977                                 fgkRubyCageScrewHoleY/2+epsilon, fgkRubyCageScrewHoleR);
4978   TGeoTranslation *trScrewHoleFoot = new TGeoTranslation("trScrewHoleFoot",
4979                                          fgkRubyCageX/2-fgkRubyCageHoleDX/2,
4980                                         -fgkRubyCageY/2+fgkRubyCageScrewHoleY/2, 0);
4981   trScrewHoleFoot->RegisterYourself();
4982
4983
4984   // pieces which differ
4985   Double_t rubyCageVInternBoxX = fgkRubyCageVIntern - fgkRubyCageInternSide/2;
4986
4987   TGeoBBox *rubyCageVInternBox = new TGeoBBox("rubyCageVInternBox",rubyCageVInternBoxX/2,
4988                                      fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2);
4989
4990   TGeoTranslation *trRubyCageVInternBox = new TGeoTranslation("trRubyCageVInternB",
4991                          fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX/2,0,0);
4992   trRubyCageVInternBox->RegisterYourself();
4993
4994   TGeoTrd1 *rubyCageVInternTriangl = new TGeoTrd1("rubyCageVInternTriangl", 0,
4995                                      fgkRubyCageInternSide/2, fgkRubyCageY/2+epsilon,
4996                                                   fgkRubyCageInternSide/4);
4997
4998   TGeoCombiTrans *trRubyCageVInternTriangl = new TGeoCombiTrans("trRubyCageVInternTriangl",
4999         fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX-fgkRubyCageInternSide/4
5000                                                                 +epsilon,0,0, rotV );
5001   trRubyCageVInternTriangl->RegisterYourself();
5002
5003   //---
5004   TGeoCompositeShape *rubyCageSquare = new TGeoCompositeShape("rubyCageSquare",
5005                                            "rubyCageBox-(rubyCageInternBox"
5006                                  "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)");
5007
5008   TGeoVolume *vRubyCageSquare = new TGeoVolume("vRubyCageSquare",
5009                                                rubyCageSquare, stainless);
5010   vRubyCageSquare->SetLineColor(10);
5011
5012   TGeoCompositeShape *rubyCageV = new TGeoCompositeShape("rubyCageV",
5013                                  "rubyCageBox-(rubyCageVInternBox:trRubyCageVInternB"
5014                                  "+rubyCageVInternTriangl:trRubyCageVInternTriangl"
5015                                  "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)");
5016   TGeoVolume *vRubyCageV = new TGeoVolume("vRubyCageV", rubyCageV, stainless);
5017   vRubyCageV->SetLineColor(10);
5018
5019   if(GetDebug(3)) { // Remove compiler warning.
5020     rubyCageBox->InspectShape();
5021     rubyCageInternBox->InspectShape();
5022     screwHole->InspectShape();
5023     screwHoleFoot->InspectShape();
5024     rubyCageVInternBox->InspectShape();
5025     rubyCageVInternTriangl->InspectShape();
5026   }
5027
5028   supportRing->AddNode(vRubyCageSquare, 0, 0);
5029   //supportRing->AddNode(vRubyCageV, 0, 0);
5030   return supportRing;
5031 }
5032
5033
5034
5035 //________________________________________________________________________
5036 void AliITSv11GeometrySDD::CreateSDDsensor() {
5037 //
5038 // return a box containing the SDD sensor
5039 //
5040
5041   TGeoMedium *airSDD         = GetMedium("SDD AIR$");
5042   TGeoMedium *siliconSDD     = GetMedium("SDD SI insensitive$");  // ITSsddSi
5043   TGeoMedium *siliconSDDsens = GetMedium("SI$");                  // ITSsddSi
5044   TGeoMedium *alSDD          = GetMedium("AL$");                  // ITSal
5045   TGeoMedium *polyhamideSDD  = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
5046   TGeoMedium *glassSDD       = GetMedium("STDGLASS$");            // StdGlass
5047
5048
5049   Double_t rWraping = fgkWaferThickness/2+fgkWaHVcableAlThick+fgkWaHVcablePolyThick;
5050   Double_t witdhCableBox = (fgkWaHVcableWitdh - TMath::Pi()*rWraping)/2;
5051   // width : in the beam direction !
5052
5053   Double_t sensoxBoxLength = ( fgkWaferLength +
5054                                2*(rWraping+witdhCableBox-fgkWaHVcableDW) );
5055   // Makes life easier to include the space for the WA HV cable on both sides
5056   Double_t sensoxBoxThick = fgkWaferThickness +
5057                             2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
5058
5059 //   cout << "fgkWaferLength=" << fgkWaferLength << " sensoxBoxLength="<< sensoxBoxLength <<endl;
5060 //   cout << "fgkWaferThickness=" << fgkWaferThickness << " sensoxBoxThick=" << sensoxBoxThick << endl;
5061
5062   TGeoBBox *box = new TGeoBBox("ITSsddSensorBox",
5063                       fgkWaferWidth/2, sensoxBoxThick/2, sensoxBoxLength/2);
5064
5065   fSDDsensor3 = new TGeoVolume("ITSsddSensor3", box, airSDD);
5066   fSDDsensor4 = new TGeoVolume("ITSsddSensor4", box, airSDD);
5067
5068
5069   //****************************
5070   // silicon wafer
5071   //****************************
5072   if (fAddSensors) {
5073     // we need 2 different sensor objects, because they have to have different names
5074     // This is required for the step manager
5075
5076     TGeoBBox *waferShape = new TGeoBBox("ITSsddWaferShape",
5077                                fgkWaferWidth/2, fgkWaferThickness/2, fgkWaferLength/2);
5078
5079
5080     TGeoVolume *wafer3 = new TGeoVolume("ITSsddWafer3", waferShape, siliconSDD);
5081     wafer3->SetLineColor(fColorSilicon);
5082     TGeoBBox *sensBox3 = new TGeoBBox("ITSsddSensorSensBox3",
5083                         fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2);
5084     TGeoVolume *sensVol3 = new TGeoVolume(fgSDDsensitiveVolName3,sensBox3, siliconSDDsens);
5085     sensVol3->SetLineColor(fColorSilicon+5);
5086     wafer3->AddNode(sensVol3, 1, 0);
5087     fSDDsensor3->AddNode(wafer3, 1, 0);
5088
5089     TGeoVolume *wafer4 = new TGeoVolume("ITSsddWafer4", waferShape, siliconSDD);
5090     wafer4->SetLineColor(fColorSilicon);
5091     TGeoBBox *sensBox4 = new TGeoBBox("ITSsddSensorSensBox4",
5092                         fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2);
5093     TGeoVolume *sensVol4 = new TGeoVolume(fgSDDsensitiveVolName4,sensBox4, siliconSDDsens);
5094     sensVol4->SetLineColor(fColorSilicon+5);
5095     wafer4->AddNode(sensVol4, 1, 0);
5096     fSDDsensor4->AddNode(wafer4, 1, 0);
5097   };
5098
5099   //****************************
5100   // glass
5101   //****************************
5102   TGeoBBox *glass = new TGeoBBox("ITSsddGlassBox", fgkSensorGlassLX/2,
5103                                  fgkSensorGlassLY/2, fgkSensorGlassLZ/2);
5104   TGeoVolume *vGlass  = new  TGeoVolume("ITSsddGlass",glass, glassSDD);
5105   vGlass->SetLineColor(fColorGlass);
5106   TGeoTranslation *glassTr1 = new TGeoTranslation("",fgkGlassDXOnSensor,
5107                                   fgkWaferThickness/2+fgkSensorGlassLY/2,
5108                                   fgkGlassDZOnSensor);
5109   TGeoTranslation *glassTr2 = new TGeoTranslation("",-fgkGlassDXOnSensor,
5110                                   fgkWaferThickness/2+fgkSensorGlassLY/2,
5111                                   fgkGlassDZOnSensor);
5112   TGeoTranslation *glassTr3 = new TGeoTranslation("",fgkGlassDXOnSensor,
5113                                   fgkWaferThickness/2+fgkSensorGlassLY/2,
5114                                   -fgkGlassDZOnSensor);
5115   TGeoTranslation *glassTr4 = new TGeoTranslation("",-fgkGlassDXOnSensor,
5116                                   fgkWaferThickness/2+fgkSensorGlassLY/2,
5117                                   -fgkGlassDZOnSensor);
5118   fSDDsensor3->AddNode(vGlass, 1, glassTr1);
5119   fSDDsensor3->AddNode(vGlass, 2, glassTr2);
5120   fSDDsensor3->AddNode(vGlass, 3, glassTr3);
5121   fSDDsensor3->AddNode(vGlass, 4, glassTr4);
5122
5123   fSDDsensor4->AddNode(vGlass, 1, glassTr1);
5124   fSDDsensor4->AddNode(vGlass, 2, glassTr2);
5125   fSDDsensor4->AddNode(vGlass, 3, glassTr3);
5126   fSDDsensor4->AddNode(vGlass, 4, glassTr4);
5127
5128   //****************************
5129   // Wrap-around cable
5130   //****************************
5131   if (fAddHVcables) {
5132   AliITSv11GeomCableFlat waHVCable("ITSsddWaHVCableU",witdhCableBox,
5133                                       fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
5134   waHVCable.SetNLayers(2);
5135   waHVCable.SetLayer(0, fgkWaHVcablePolyThick,polyhamideSDD,fColorPolyhamide);
5136   waHVCable.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
5137   waHVCable.SetInitialNode(fSDDsensor3);
5138
5139   Double_t x1[3], x2[3], vX[3] = {1,0,0};
5140   x1[0] = -fgkWaHVcableLength/2;
5141   x2[0] = -x1[0];
5142   x1[1] = (fgkWaferThickness + waHVCable.GetThickness())/2;
5143   x2[1] = x1[1];
5144   x1[2] = fgkWaferLength/2+waHVCable.GetWidth()/2-fgkWaHVcableDW;
5145   x2[2] = x1[2];
5146
5147   waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5148   waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5149   TGeoCombiTrans *ctSegment = 0;
5150   TGeoVolume* segment = waHVCable.CreateAndInsertBoxCableSegment(1,-90, &ctSegment);
5151   fSDDsensor4->AddNode(segment, 1, ctSegment);
5152
5153   x1[1] = -x1[1];
5154   x2[1] = x1[1];
5155   waHVCable.SetName("ITSsddWaHVCableD");
5156   waHVCable.ResetPoints();
5157   waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5158   waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5159   segment = waHVCable.CreateAndInsertBoxCableSegment(1, 90, &ctSegment);
5160   fSDDsensor4->AddNode(segment, 1, ctSegment);
5161
5162   AliITSv11GeomCableRound waHVCableFold("ITSsddWaHVCableFold",
5163                                            rWraping);
5164   waHVCableFold.SetPhi(180,360);
5165   waHVCableFold.SetNLayers(2);
5166   waHVCableFold.SetLayer(0, fgkWaferThickness/2+fgkWaHVcablePolyThick,
5167                          polyhamideSDD, fColorPolyhamide);
5168   waHVCableFold.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
5169   waHVCableFold.SetInitialNode(fSDDsensor3);
5170   x1[1] = 0;
5171   x2[1] = 0;
5172   x1[2] = fgkWaferLength/2-fgkWaHVcableDW+witdhCableBox;
5173   x2[2] = x1[2];
5174   waHVCableFold.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5175   waHVCableFold.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5176   segment = waHVCableFold.CreateAndInsertCableSegment(1, &ctSegment);
5177   fSDDsensor4->AddNode(segment, 1, ctSegment);
5178
5179
5180   //****************************
5181   // transition cable
5182   //****************************
5183   Double_t headRadius = (fgkTransitHVHeadLX*fgkTransitHVHeadLX/4.+
5184                          fgkTransitHVHeadLZ*fgkTransitHVHeadLZ)
5185                         /(2.*fgkTransitHVHeadLZ);
5186   Double_t theta = TMath::ATan2(fgkTransitHVHeadLX/2,
5187                                 headRadius-fgkTransitHVHeadLZ)
5188                    *TMath::RadToDeg();
5189
5190   TGeoTubeSeg *headPoly = new TGeoTubeSeg(0,headRadius,
5191                                           fgkTransitHVPolyThick/2,
5192                                           90-theta,90+theta);
5193   headPoly->SetName("headPoly");
5194   TGeoTranslation *headPolyTr = new TGeoTranslation(0,0,
5195                                     -fgkTransitHVPolyThick/2);
5196   headPolyTr->SetName("headPolyTr");
5197   headPolyTr->RegisterYourself();
5198
5199   TGeoTubeSeg *headAl = new TGeoTubeSeg(0,headRadius,
5200                                         fgkTransitHVAlThick/2,
5201                                         90-theta,90+theta);
5202   headAl->SetName("headAl");
5203   TGeoTranslation *headAlTr = new TGeoTranslation(0,0,
5204                                   -fgkTransitHVPolyThick
5205                                   -fgkTransitHVAlThick/2);
5206   headAlTr->SetName("headAlTr");
5207   headAlTr->RegisterYourself();
5208
5209   TGeoBBox *cache = new TGeoBBox(fgkTransitHVHeadLX/2,
5210                                  (headRadius-fgkTransitHVHeadLZ)/2,
5211                        (fgkTransitHVPolyThick+fgkTransitHVAlThick)/2);
5212   cache->SetName("cache");
5213
5214   TGeoTranslation *headCacheTr = new TGeoTranslation(0,
5215                                 (headRadius-fgkTransitHVHeadLZ)/2,
5216                                  -(fgkTransitHVPolyThick
5217                                    +fgkTransitHVAlThick)/2);
5218   headCacheTr->SetName("cacheTr");
5219   headCacheTr->RegisterYourself();
5220
5221   TGeoCompositeShape *headPolyComp = new TGeoCompositeShape(
5222                       "headPoly:headPolyTr-cache:cacheTr");
5223   TGeoVolume *vHeadPolyComp = new TGeoVolume(
5224               "ITSsddHVtransitHeadPoly",headPolyComp, polyhamideSDD);
5225   vHeadPolyComp->SetLineColor(fColorPolyhamide);
5226   TGeoCompositeShape *headAlComp = new TGeoCompositeShape(
5227                                        "headAl:headAlTr-cache:cacheTr");
5228   TGeoVolume *vHeadAlComp = new TGeoVolume(
5229               "ITSsddHVtransitHeadAl",headAlComp, alSDD);
5230   vHeadAlComp->SetLineColor(fColorAl);
5231
5232
5233 //   TGeoRotation rotHead("",0,90,0);
5234 //   TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2,
5235 //                -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2,
5236 //                                               &rotHead);
5237   TGeoRotation *rotHead = new TGeoRotation("",0,90,0);
5238   TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2,
5239                   -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2,
5240                                                  rotHead);
5241
5242   fSDDsensor3->AddNode(vHeadPolyComp,1,rotHeadTr);
5243   fSDDsensor3->AddNode(vHeadAlComp,1,rotHeadTr);
5244   fSDDsensor4->AddNode(vHeadPolyComp,1,rotHeadTr);
5245   fSDDsensor4->AddNode(vHeadAlComp,1,rotHeadTr);
5246
5247   //---
5248   AliITSv11GeomCableFlat transitHVCable("ITSsddHVtransitCenter",
5249                                         fgkTransitHVBondingLZ,
5250                             fgkTransitHVPolyThick+fgkTransitHVAlThick);
5251   transitHVCable.SetNLayers(2);
5252   transitHVCable.SetLayer(0, fgkTransitHVPolyThick,polyhamideSDD,
5253                           fColorPolyhamide);
5254   transitHVCable.SetLayer(1, fgkTransitHVAlThick, alSDD, fColorAl);
5255   transitHVCable.SetInitialNode(fSDDsensor3);
5256
5257   x1[0] = -fgkTransitHVHeadLX/2;
5258   x2[0] = -x1[0];
5259   x1[1] = (fgkWaferThickness+fgkTransitHVPolyThick+fgkTransitHVAlThick)/2;
5260   x2[1] = x1[1];
5261   x1[2] = 0;
5262   x2[2] = 0;
5263   transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5264   transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5265   segment = transitHVCable.CreateAndInsertBoxCableSegment(1,-90,&ctSegment);
5266   fSDDsensor4->AddNode(segment, 1, ctSegment);
5267
5268   transitHVCable.ResetPoints();
5269   transitHVCable.SetName("ITSsddHVtransitTail");
5270   transitHVCable.SetWidth(fgkTransitHVtailWidth);
5271   x1[0] = fgkTransitHVtailXpos;
5272   x2[0] = fgkTransitHVtailXpos;
5273   x1[2] = -fgkTransitHVBondingLZ/2;
5274   x2[2] = -fgkTransitHVBondingLZ/2-fgkTransitHVtailLength;
5275   Double_t vZ[3] = {0,0,1};
5276   transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vZ);
5277   transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vZ);
5278   segment = transitHVCable.CreateAndInsertBoxCableSegment(1,0, &ctSegment);
5279   fSDDsensor4->AddNode(segment, 1, ctSegment);
5280
5281   //---
5282   TGeoArb8 *sideLeft = new TGeoArb8( fgkTransitHVPolyThick/2 );
5283   sideLeft->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5284   sideLeft->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5285                       fgkTransitHVsideLZ);
5286   sideLeft->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5287   sideLeft->SetVertex(3, fgkTransitHVHeadLX/2, 0);
5288   sideLeft->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5289   sideLeft->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5290                       fgkTransitHVsideLZ);
5291   sideLeft->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5292   sideLeft->SetVertex(7, fgkTransitHVHeadLX/2, 0);
5293
5294   TGeoArb8 *sideLeftAl = new TGeoArb8( fgkTransitHVAlThick/2 );
5295   sideLeftAl->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5296   sideLeftAl->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5297                         fgkTransitHVsideLZ);
5298   sideLeftAl->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5299   sideLeftAl->SetVertex(3, fgkTransitHVHeadLX/2, 0);
5300   sideLeftAl->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5301   sideLeftAl->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5302                         fgkTransitHVsideLZ);
5303   sideLeftAl->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5304   sideLeftAl->SetVertex(7, fgkTransitHVHeadLX/2, 0);
5305
5306   // sideRight is not there actually
5307 //   TGeoArb8 *sideRight = new TGeoArb8( fgkTransitHVPolyThick/2 );
5308 //   sideRight->SetVertex(0, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
5309 //   sideRight->SetVertex(1, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
5310 //                     fgkTransitHVsideLZ);
5311 //   sideRight->SetVertex(2, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
5312 //   sideRight->SetVertex(3, -fgkTransitHVHeadLX/2, 0);
5313 //   sideRight->SetVertex(4, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
5314 //   sideRight->SetVertex(5, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
5315 //                     fgkTransitHVsideLZ);
5316 //   sideRight->SetVertex(6, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
5317 //   sideRight->SetVertex(7, -fgkTransitHVHeadLX/2, 0);
5318
5319 //   TGeoRotation rotSide("",0,-90,0);
5320 //   TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
5321 //                              (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5322 //                              -fgkTransitHVBondingLZ/2,&rotSide);
5323 //   TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
5324 //                             (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5325 //                             -fgkTransitHVBondingLZ/2, &rotSide);
5326 //   TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0,
5327 //                fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
5328 //                -fgkTransitHVBondingLZ/2, &rotSide);
5329   TGeoRotation *rotSide = new TGeoRotation("",0,-90,0);
5330 //   TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
5331 //                              (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5332 //                              -fgkTransitHVBondingLZ/2,rotSide);
5333   TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
5334                                (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5335                                -fgkTransitHVBondingLZ/2, rotSide);
5336   TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0,
5337                   fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
5338                   -fgkTransitHVBondingLZ/2, rotSide);
5339
5340   TGeoVolume *vSideLeft = new TGeoVolume("ITSsddHVtransitSideLeft",
5341                                          sideLeft,polyhamideSDD);
5342   vSideLeft->SetLineColor(fColorPolyhamide);
5343   TGeoVolume *vSideLeftAl = new TGeoVolume("ITSsddHVtransitSideLeftAl",
5344                                            sideLeftAl,alSDD);
5345   vSideLeftAl->SetLineColor(fColorAl);
5346
5347 //   TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight",
5348 //                                        sideRight,polyhamideSDD);
5349 //   vSideRight->SetLineColor(fColorPolyhamide);
5350
5351   fSDDsensor3->AddNode(vSideLeft,   1, sideLeftTr);
5352   fSDDsensor3->AddNode(vSideLeftAl, 1, sideLeftAlTr);
5353 //   fSDDsensor3->AddNode(vSideRight,  1, sideRightTr);
5354
5355   fSDDsensor4->AddNode(vSideLeft,   1, sideLeftTr);
5356   fSDDsensor4->AddNode(vSideLeftAl, 1, sideLeftAlTr);
5357 //   fSDDsensor4->AddNode(vSideRight,  1, sideRightTr);
5358   };
5359
5360   //****************************
5361   if(GetDebug(1)) {
5362     fSDDsensor3->CheckOverlaps(0.01);
5363     fSDDsensor4->CheckOverlaps(0.01);
5364   }
5365
5366   fSDDsensor3->SetVisibility(kFALSE);
5367   fSDDsensor4->SetVisibility(kFALSE);
5368 }
5369
5370 /*
5371 //________________________________________________________________________
5372 TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) {
5373   //
5374   // return a box volume containing the detectors
5375   //
5376
5377   TGeoMedium *airSDD = GetMedium("SDD AIR$");
5378
5379   Int_t    nDetectors   = fgkLay3Ndet;
5380   Double_t ladderLength = fgkLay3LadderLength;
5381   Double_t *sensorZPos  = fLay3sensorZPos;
5382
5383   if (iLay==3) {}
5384   else if (iLay==4) {
5385     nDetectors   = fgkLay4Ndet;
5386     ladderLength = fgkLay4LadderLength;
5387     sensorZPos   = fLay4sensorZPos;
5388   } else {
5389     printf("AliITSv11GeometrySDD::CreateDetectors: Error : Wrong layer");
5390   };
5391
5392   char name[30];
5393   Double_t volThickness = ( fgkLadWaferSep + 2*fgkWaferThickness +
5394                             2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick));
5395
5396   sprintf(name,"ITSsddDetBox%i",iLay);
5397   TGeoBBox *detBox = new TGeoBBox(name, fgkWaferWidth/2, volThickness/2,
5398                          ladderLength*((nDetectors-0.5)/nDetectors)/2);
5399   TGeoVolume *virtualDet = new TGeoVolume("ITSsddLadd",detBox, airSDD);
5400
5401     for (Int_t i=0; i<nDetectors; i++) {
5402         Double_t localZ = sensorZPos[i];
5403         Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5404         if (iLay==3) if (i%2!=0) localY = -localY;
5405         if (iLay==4) if (i%2==0) localY = -localY;
5406         sprintf(name, "ITSsddLay%iSensorPos%i",iLay, i);
5407
5408         if (i >= nDetectors/2) {
5409           TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5410           sensorPos->SetName(name);
5411           virtualDet->AddNode(fSDDsensor, i, sensorPos);
5412         }
5413         else {
5414           TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5415           TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5416                                                  localZ, rotSensor);
5417           sensorPos->SetName(name);
5418           virtualDet->AddNode(fSDDsensor, i, sensorPos);
5419         };
5420     }
5421
5422     if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5423     virtualDet->SetVisibility(kFALSE);
5424     return virtualDet;
5425 }
5426 */
5427
5428 //________________________________________________________________________
5429 TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssembly(Int_t iLay) {
5430 //
5431 // return a box volume containing the detectors
5432 //
5433
5434   Int_t    nDetectors   = fgkLay3Ndet;
5435   Double_t ladderLength = fgkLay3LadderLength;
5436   Double_t *sensorZPos  = fLay3sensorZPos;
5437   TGeoVolume *sensorSDD = fSDDsensor3;
5438
5439   if (iLay==3) {}
5440   else if (iLay==4) {
5441     nDetectors   = fgkLay4Ndet;
5442     ladderLength = fgkLay4LadderLength;
5443     sensorZPos   = fLay4sensorZPos;
5444     sensorSDD    = fSDDsensor4;
5445   } else {
5446     printf("AliITSv11GeometrySDD::CreateDetectorsAssembly: Error:Wrong layer");
5447   };
5448
5449   char name[30];
5450   snprintf(name,30,"ITSsddDetBox%i",iLay);
5451
5452   TGeoVolumeAssembly  *virtualDet = new TGeoVolumeAssembly("ITSsddLadd");
5453
5454   for (Int_t i=0; i<nDetectors; i++) {
5455     Double_t localZ = sensorZPos[i];
5456     Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5457     if (iLay==3) if (i%2!=0) localY = -localY;
5458     if (iLay==4) if (i%2==0) localY = -localY;
5459     snprintf(name, 30, "ITSsddLay%iSensorPos%i",iLay, i);
5460
5461     if (i >= nDetectors/2) {
5462       TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5463       sensorPos->SetName(name);
5464       virtualDet->AddNode(sensorSDD, i, sensorPos);
5465     }
5466     else {
5467       TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5468       TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5469                                                      localZ, rotSensor);
5470       sensorPos->SetName(name);
5471       virtualDet->AddNode(sensorSDD, i, sensorPos);
5472     };
5473   }
5474
5475   if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5476   return virtualDet;
5477 }
5478
5479
5480 //________________________________________________________________________
5481 TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssemblyLadd2() {
5482 //
5483 // return a box volume containing the detectors
5484 // Special case for Layer 3 Ladder 2 which is rotated (cannot simply
5485 // rotate the standard volume, because the module numbering would be wrong)
5486 // M.Sitta 25 Nov 2009
5487 //
5488
5489   Int_t    nDetectors   = fgkLay3Ndet;
5490   Double_t *sensorZPos  = fLay3sensorZPos;
5491   TGeoVolume *sensorSDD = fSDDsensor3;
5492
5493   char name[30];
5494   snprintf(name,30,"ITSsddDetBoxLadd2");
5495
5496   TGeoVolumeAssembly  *virtualDet = new TGeoVolumeAssembly("ITSsddLadd");
5497
5498   for (Int_t i=0; i<nDetectors; i++) {
5499     Double_t localZ = (-1.)*sensorZPos[nDetectors-1-i];
5500     Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5501     if (i%2==0) localY = -localY;
5502     snprintf(name, 30, "ITSsddLayLadd2SensorPos%i", i);
5503
5504     if (i >= nDetectors/2) {
5505       TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5506       sensorPos->SetName(name);
5507       virtualDet->AddNode(sensorSDD, i, sensorPos);
5508     }
5509     else {
5510       TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5511       TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5512                                                      localZ, rotSensor);
5513       sensorPos->SetName(name);
5514       virtualDet->AddNode(sensorSDD, i, sensorPos);
5515     };
5516   }
5517
5518   if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5519   return virtualDet;
5520 }
5521
5522
5523 //________________________________________________________________________
5524 Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD,
5525                                                  Int_t startMod) {
5526 //
5527 // export the geometry in a AliITSgeom object
5528 // Obsolete
5529 //
5530
5531   if (! geom) {
5532     printf("error:Try to fill null (AliITSgeom *) object");
5533     return kFALSE;
5534   };
5535   if (! fMotherVol) {
5536     printf("error:Try to set sensor geometry while geometry is not defined\n");
5537     return kFALSE;
5538   };
5539
5540   const Float_t kDxyz[3] = {fgkWaferWidthSens/2., fgkWaferThickSens/2.,
5541                             fgkWaferLengthSens/2.};
5542   if(!(geom->IsShapeDefined(kSDD)))
5543     geom->ReSetShape(kSDD, new AliITSgeomSDD256(3, kDxyz));
5544
5545   char layerName[30];
5546   char ladderName[30];
5547   char sensorName[30];
5548   char senstivName[30];
5549   const Int_t kNLay = 2;
5550   const Int_t kNLadd[kNLay] = {fgkLay3Nladd, fgkLay4Nladd};
5551   const Int_t kNDet[kNLay]  = {fgkLay3Ndet,  fgkLay4Ndet};
5552
5553   if (GetDebug(1))
5554     printf("AliITSv11GeometrySDD::SetSensorGeometry(), nodes found :\n");
5555
5556   Int_t firstSDDmod = startMod;
5557   for (Int_t iLay=0; iLay<kNLay; iLay++) {
5558     /////////////////////////////////////////
5559     snprintf(layerName, 30, "ITSsddLayer%i_1",iLay+3);
5560     TGeoNode *layNode = fMotherVol->GetNode(layerName);
5561     if (layNode) {
5562       if (GetDebug(1)) printf("%s\n",layNode->GetName());
5563       TGeoVolume *layVolume = layNode->GetVolume();
5564       TGeoHMatrix layMatrix(*layNode->GetMatrix());
5565
5566       for (Int_t iLadd=0; iLadd<kNLadd[iLay]; iLadd++) {
5567         /////////////////////////////////////////
5568         snprintf(ladderName, 30, "ITSsddLadd_%i", iLadd);
5569         TGeoNode *laddNode = layVolume->GetNode(ladderName);
5570         if (laddNode) {
5571           if (GetDebug(1)) printf("|   %s\n",laddNode->GetName());
5572           TGeoVolume *laddVolume = laddNode->GetVolume();
5573           TGeoHMatrix laddMatrix(layMatrix);
5574           laddMatrix.Multiply(laddNode->GetMatrix());
5575
5576           for (Int_t iDet=0; iDet<kNDet[iLay]; iDet++) {
5577             /////////////////////////////////////////
5578             snprintf(sensorName, 30, "ITSsddSensor_%i",iDet);
5579             TGeoNode *detNode = laddVolume->GetNode(sensorName);
5580             if (detNode) {
5581               if (GetDebug(1)) printf("|   |   %s\n",detNode->GetName());
5582               TGeoVolume *detVolume = detNode->GetVolume();
5583               TGeoHMatrix detMatrix(laddMatrix);
5584               detMatrix.Multiply(detNode->GetMatrix());
5585
5586               TGeoNode *wafNode = detVolume->GetNode("ITSsddWafer_1");
5587               if (wafNode) {
5588                 TGeoVolume *wafVolume = wafNode->GetVolume();
5589                 TGeoHMatrix wafMatrix(detMatrix);
5590                 detMatrix.Multiply(wafNode->GetMatrix());
5591                 //--------------------------------------------------------
5592                 snprintf(senstivName, 30, "%s%s", fgSDDsensitiveVolName3,"_1");
5593                 TGeoNode *sensitivNode = wafVolume->GetNode(senstivName);
5594               if (sensitivNode) {
5595                 TGeoHMatrix sensMatrix(wafMatrix);
5596                 sensMatrix.Multiply(sensitivNode->GetMatrix());
5597
5598                 // Sticking to the convention for local wafer coordinate
5599                 // in AliITSgeom :
5600                 if (iDet >= kNDet[iLay]/2) {
5601                   //              TGeoRotation rotY("",0,180,0);
5602                   TGeoRotation rotY("",-180,-180,0);
5603                   sensMatrix.Multiply(&rotY);
5604                 };
5605                 // Creating the matrix in AliITSgeom for
5606                 // this sensitive volume :
5607                 Double_t *trans = sensMatrix.GetTranslation();
5608                 Double_t *r     = sensMatrix.GetRotationMatrix();
5609                 Double_t rot[10] = {r[0],r[1],r[2],
5610                                     r[3],r[4],r[5],
5611                                     r[6],r[7],r[8], 1.0};
5612                 //rot[9]!=0.0 => not a unity matrix
5613                 geom->CreateMatrix(startMod,iLay+iLaySDD,iLadd+1,iDet+1,
5614                                   kSDD,trans,rot);
5615                 // iLadd+1, iDet+1 because ladd. and det. start at +1
5616                 // elsewhere
5617                 startMod++;
5618
5619               } else
5620                 printf("Error (ExportSensorGeometry) %s not found !\n",
5621                        senstivName);
5622               } else
5623                 printf("Error (ExportSensorGeometry) %s not found !\n",
5624                        "ITSsddWafer_1");
5625             } else
5626               printf("Error (ExportSensorGeometry) %s not found !\n",
5627                      sensorName);
5628           };
5629         } else
5630           printf("Error (ExportSensorGeometry) %s not found !\n",
5631                  ladderName);
5632       };
5633     } else
5634       printf("Error (ExportSensorGeometry) %s not found !\n",
5635              layerName);
5636   };
5637
5638   return (startMod-firstSDDmod);
5639 }
5640
5641
5642 //________________________________________________________________________
5643 Int_t AliITSv11GeometrySDD::
5644 GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const {
5645 //
5646 // Function which gives the layer, ladder and det.
5647 // index of the current volume. To be used in
5648 // AliITS::StepManager()
5649   //
5650
5651   if (gGeoManager->GetLevel()<3) return kFALSE;
5652   // Get the det index :
5653   TGeoNode *node = gGeoManager->GetMother(2);
5654   if (!node) return kFALSE;
5655   det = node->GetNumber()+1;
5656
5657   // Get the ladder index :
5658   node = gGeoManager->GetMother(3);
5659   if (!node) return kFALSE;
5660   ladd = node->GetNumber()+1;
5661
5662  // Get the layer index :
5663   if (node->GetNdaughters()==fgkLay3Ndet)
5664     lay = 3;            // this has to be equal to the iLaySDD argument given to ExportSensorGeometry() !!!
5665   else lay = 4;
5666
5667   return kTRUE;
5668 }
5669
5670
5671 //________________________________________________________________________
5672 TGeoPcon* AliITSv11GeometrySDD::CreateConeConstSection(Double_t r1max, Double_t z1,
5673                                                        Double_t r2max, Double_t z2,
5674                                                        Double_t section, Int_t nDiv)
5675 {
5676   // Creates a cone along z where the section is approximately constant
5677   // with z. This is for simulation of cables, because a cone with a constant
5678   // radius difference would show a quantity of matter increasing with z...
5679   // The max radius of the created Pcon is evolving linearly, the min radius
5680   // is calculated at several steps (nDiv).
5681   // z2 > z1 (required by the Pcon)
5682
5683   TGeoPcon *myPcon = new TGeoPcon(0, 360, 1+nDiv);
5684
5685   Double_t dr = (r2max-r1max)/nDiv;
5686   Double_t dz = (z2-z1)/nDiv;
5687   Double_t r1minI, r2minI, r1maxI, r2maxI;
5688   Double_t z1I, z2I;
5689
5690   Double_t lZ = TMath::Sqrt((r2max-r1max)*(r2max-r1max) + (z2-z1)*(z2-z1));
5691   Double_t cosAlpha = (z2-z1)/lZ;
5692
5693   r1minI = TMath::Sqrt(r1max*r1max-section/(TMath::Pi()*cosAlpha));
5694   myPcon->DefineSection(0, z1, r1minI, r1max);
5695
5696   for (Int_t i=0; i<nDiv; i++) {
5697
5698     z1I = z1 + i*dz;
5699     z2I = z1I + dz;
5700     r1maxI = r1max + i*dr;
5701     r2maxI = r1maxI + dr;
5702
5703     r2minI =  TMath::Sqrt(r2maxI*r2maxI-section/(TMath::Pi()*cosAlpha));
5704     myPcon->DefineSection(i+1, z2I, r2minI, r2maxI);
5705   }
5706   return myPcon;
5707 }
5708
5709
5710 //________________________________________________________________________
5711 Double_t AliITSv11GeometrySDD::GetConeZ(Double_t r, Double_t refR1, Double_t refR2,
5712                                         Double_t refZ1, Double_t refZ2) {
5713   // just a helping function
5714   return refZ1+(refZ2-refZ1)*(r-refR1)/(refR2-refR1);
5715 }
5716
5717 //________________________________________________________________________
5718 Int_t AliITSv11GeometrySDD::CreateAndInsetConeCablePart(TGeoVolume *mother, Double_t angle,
5719                                                         Int_t nLay3, Int_t nLay4,
5720                                                         Double_t r1, Double_t z1,
5721                                                         Double_t r2, Double_t z2) {
5722
5723   // Create some cables portions from SDD modules grouped
5724   // and attached at the border of the SSD cone
5725
5726   TGeoMedium *copper     = GetMedium("COPPER$");
5727   TGeoMedium *plastic    = GetMedium("SDDKAPTON (POLYCH2)$");
5728   TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$");
5729
5730   char titleCable[30];
5731   snprintf(titleCable,30,"cableSDDport%i",(Int_t)angle);
5732
5733   //---
5734   Double_t section = (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod)*(nLay3+nLay4);
5735   Double_t thickness = 1.; // let's fix the thickness, then calculate the width
5736   Double_t width     = section/thickness;
5737   Double_t thickCu   = thickness*fgkSectionCuPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5738                                                      +fgkSectionGlassPerMod);
5739
5740   Double_t thickPlast = thickness*fgkSectionPlastPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5741                                                          +fgkSectionGlassPerMod);
5742
5743   Double_t thickGlass = thickness*fgkSectionGlassPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5744                                                          +fgkSectionGlassPerMod);
5745
5746   Double_t hypothenus   = TMath::Sqrt( (r2-r1)*(r2-r1) + (z2-z1)*(z2-z1) );
5747   Double_t cosAlpha     = (z2-z1)/hypothenus;
5748   Double_t radius1Cable = TMath::Sqrt(r1*r1 - width*width/4) - 0.5*thickness/cosAlpha;
5749   Double_t radius2Cable = TMath::Sqrt(r2*r2 - width*width/4) - 0.5*thickness/cosAlpha;
5750   angle *= TMath::DegToRad();
5751   Double_t x1 = radius1Cable*TMath::Cos(angle), y1 = radius1Cable*TMath::Sin(angle);
5752   Double_t x2 = radius2Cable*TMath::Cos(angle), y2 = radius2Cable*TMath::Sin(angle);
5753   Double_t pos1[3] = {x1,y1,z1};
5754   Double_t pos2[3] = {x2,y2,z2};
5755   Double_t zVect[3] = {0,0,1};
5756
5757   AliITSv11GeomCableFlat cable(titleCable,width,thickness);
5758   cable.SetNLayers(3);
5759   cable.SetLayer(0, thickPlast, plastic, kYellow);
5760   cable.SetLayer(1, thickCu, copper, kRed);
5761   cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
5762
5763   cable.AddCheckPoint( mother, 0, pos1, zVect );
5764   cable.AddCheckPoint( mother, 1, pos2, zVect );
5765   cable.SetInitialNode(mother);
5766   cable.CreateAndInsertCableSegment(1);
5767
5768   return kTRUE;
5769 }
5770
5771
5772
5773 //________________________________________________________________________
5774 void AliITSv11GeometrySDD::SDDCables(TGeoVolume *moth)
5775 {
5776 //
5777 // Creates and inserts the SDD cables running on SDD and SSD cones
5778 //
5779 // Input:
5780 //         moth : the TGeoVolume owing the volume structure
5781 // Output:
5782 //
5783 // Created:         ???       Ludovic Gaudichet
5784 // Updated:      15 Mar 2008  Mario Sitta
5785 // Updated:      14 Apr 2008  Mario Sitta            Overlap fixes
5786 // Updated:      09 May 2008  Mario Sitta            SSD overlap fixes
5787 //
5788
5789   TGeoMedium *copper       = GetMedium("COPPER$");
5790   TGeoMedium *plastic      = GetMedium("SDDKAPTON (POLYCH2)$");
5791   TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$");
5792   TGeoMedium *airSDD       = GetMedium("SDD AIR$");
5793
5794
5795   //==================================
5796   //
5797   //==================================
5798
5799   Double_t nModLay3 = fgkLay3Nladd*fgkLay3Ndet;
5800   Double_t nModLay4 = fgkLay4Nladd*fgkLay4Ndet;
5801
5802   Double_t sectionLay3Cu      = fgkCableBendRatio*fgkSectionCuPerMod*nModLay3/2;
5803   Double_t sectionLay3Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay3/2;
5804   Double_t sectionLay3Glass   = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay3/2;
5805
5806   Double_t sectionLay4Cu      = fgkCableBendRatio*fgkSectionCuPerMod*nModLay4/2;
5807   Double_t sectionLay4Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay4/2;
5808   Double_t sectionLay4Glass   = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay4/2;
5809
5810   // Do not use hardcoded numbers, get them from real shapes - M.S. 15/03/08
5811   TGeoVolume *sddCone = gGeoManager->GetVolume("SDDCarbonFiberCone");
5812   TGeoPcon *sddConeShape = (TGeoPcon*)sddCone->GetShape();
5813
5814   TGeoVolume *sddCylinder = gGeoManager->GetVolume("SDDCarbonFiberCylinder");
5815   TGeoTube *sddCylinderShape = (TGeoTube*)sddCylinder->GetShape();
5816
5817   // (were fgkConeSDDr1, fgkConeSDDr2, fgkConeSDDz1, fgkConeSDDz2 hardcoded)
5818   Double_t coneSDDr1 = sddConeShape->GetRmin(5);
5819   Double_t coneSDDr2 = sddConeShape->GetRmin(3);
5820
5821   Double_t coneSDDz1 = sddConeShape->GetZ(9) - sddConeShape->GetZ(5) +
5822                        sddCylinderShape->GetDz();
5823   Double_t coneSDDz2 = sddConeShape->GetZ(9) - sddConeShape->GetZ(3) +
5824                        sddCylinderShape->GetDz();
5825
5826   // Calculate z1, z2 thanks to R1 and R2
5827   Double_t sddCableZ1 = GetConeZ(fgkSDDCableR1, coneSDDr1, coneSDDr2,
5828                                                 coneSDDz1, coneSDDz2);
5829   Double_t sddCableZ2 = GetConeZ(fgkSDDCableR2, coneSDDr1, coneSDDr2,
5830                                                 coneSDDz1, coneSDDz2);
5831   Double_t sddCableZ3 = GetConeZ(fgkSDDCableR3, coneSDDr1, coneSDDr2,
5832                                                 coneSDDz1, coneSDDz2);
5833
5834   TGeoRotation *rotCableSDD = new TGeoRotation("rotCableSDD",0,180,0);
5835
5836   //==================================
5837   //  first set of cones : cables from layer 3
5838   //==================================
5839
5840   TGeoPcon* pcon1all = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
5841                                               fgkSDDCableR2, sddCableZ2,
5842                   sectionLay3Plastic+sectionLay3Cu+sectionLay3Glass, 1);
5843
5844   TGeoPcon* pcon1container = new TGeoPcon(0,360,2);
5845   pcon1container->DefineSection(0, sddCableZ1, pcon1all->GetRmin(0),
5846                                                pcon1all->GetRmax(0));
5847
5848   Double_t drMax = pcon1all->GetRmax(0)- pcon1all->GetRmin(0);
5849   pcon1container->DefineSection(1, sddCableZ2, pcon1all->GetRmax(1)-drMax,
5850                                                pcon1all->GetRmax(1));
5851
5852   TGeoVolume *vpcon1container = new TGeoVolume("vpcon1container",
5853                                                pcon1container, airSDD);
5854   vpcon1container->SetVisibility(kFALSE);
5855
5856   TGeoPcon* pcon1plast = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
5857                                                 fgkSDDCableR2, sddCableZ2,
5858                                                 sectionLay3Plastic, 3);
5859
5860   TGeoVolume *vpcon1plast = new TGeoVolume("ITScablesSDDpcon1Plast",
5861                                            pcon1plast, plastic);
5862   vpcon1plast->SetLineColor(kYellow);
5863   vpcon1container->AddNode(vpcon1plast, 0);
5864
5865   Double_t dr1a = fgkSDDCableR1 - pcon1plast->GetRmin(0);
5866   TGeoPcon* pcon1Cu = CreateConeConstSection(fgkSDDCableR1 - dr1a, sddCableZ1,
5867                                              fgkSDDCableR2 - dr1a, sddCableZ2,
5868                                              sectionLay3Cu, 3);
5869
5870   TGeoVolume *vpcon1Cu = new TGeoVolume("ITScablesSDDpcon1Cu",
5871                                         pcon1Cu, copper);
5872   vpcon1Cu->SetLineColor(kRed);
5873   vpcon1container->AddNode(vpcon1Cu, 0);
5874
5875   Double_t dr1b = pcon1Cu->GetRmax(0) - pcon1Cu->GetRmin(0);
5876   TGeoPcon* pcon1glass = CreateConeConstSection(fgkSDDCableR1-dr1a-dr1b, sddCableZ1,
5877                                                 fgkSDDCableR2-dr1a-dr1b, sddCableZ2,
5878                                                 sectionLay3Glass, 3);
5879
5880   TGeoVolume *vpcon1glass = new TGeoVolume("ITScablesSDDpcon1glass",
5881                                            pcon1glass, opticalFiber);
5882   vpcon1glass->SetLineColor(kGreen);
5883   vpcon1container->AddNode(vpcon1glass, 0);
5884
5885   moth->AddNode(vpcon1container, 1);
5886   moth->AddNode(vpcon1container, 2, rotCableSDD);
5887
5888   //==================================
5889   //  2nd set of cones : cables from layer 3 and layer 4
5890   //==================================
5891
5892   TGeoPcon* pcon2all = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
5893                                               fgkSDDCableR3, sddCableZ3,
5894                                       sectionLay3Plastic+sectionLay4Plastic+
5895                                       sectionLay3Cu+sectionLay4Cu+
5896                                       sectionLay3Glass+sectionLay4Glass, 1);
5897
5898   TGeoPcon* pcon2container = new TGeoPcon(0,360,2);
5899   pcon2container->DefineSection(0, sddCableZ2, pcon2all->GetRmin(0),
5900                                                pcon2all->GetRmax(0));
5901
5902   drMax = pcon2all->GetRmax(0)- pcon2all->GetRmin(0);
5903   pcon2container->DefineSection(1, sddCableZ3, pcon2all->GetRmax(1)-drMax,
5904                                                pcon2all->GetRmax(1));
5905
5906
5907   TGeoVolume *vpcon2container = new TGeoVolume("vpcon2container",
5908                                                pcon2container, airSDD);
5909   vpcon2container->SetVisibility(kFALSE);
5910
5911   TGeoPcon* pcon2plast = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
5912                                                 fgkSDDCableR3, sddCableZ3,
5913                                                 sectionLay3Plastic+
5914                                                 sectionLay4Plastic, 3);
5915
5916   TGeoVolume *vpcon2plast = new TGeoVolume("ITScablesSDDpcon2Plast",
5917                                            pcon2plast, plastic);
5918   vpcon2plast->SetLineColor(kYellow);
5919   vpcon2container->AddNode(vpcon2plast, 0);
5920
5921   Double_t dr2a = fgkSDDCableR2 - pcon2plast->GetRmin(0);
5922   TGeoPcon* pcon2Cu = CreateConeConstSection(fgkSDDCableR2 - dr2a, sddCableZ2,
5923                                              fgkSDDCableR3 - dr2a, sddCableZ3,
5924                                              sectionLay3Cu+sectionLay4Cu, 3);
5925
5926   TGeoVolume *vpcon2Cu = new TGeoVolume("ITScablesSDDpcon2Cu",
5927                                         pcon2Cu, copper);
5928   vpcon2Cu->SetLineColor(kRed);
5929   vpcon2container->AddNode(vpcon2Cu, 0);
5930
5931   Double_t dr2b = pcon2Cu->GetRmax(0) - pcon2Cu->GetRmin(0);
5932   TGeoPcon* pcon2glass = CreateConeConstSection(fgkSDDCableR2-dr2a-dr2b, sddCableZ2,
5933                                                 fgkSDDCableR3-dr2a-dr2b, sddCableZ3,
5934                                                 sectionLay3Glass+
5935                                                 sectionLay4Glass, 3);
5936
5937   TGeoVolume *vpcon2glass = new TGeoVolume("ITScablesSDDpcon2glass",
5938                                            pcon2glass, opticalFiber);
5939   vpcon2glass->SetLineColor(kGreen);
5940   vpcon2container->AddNode(vpcon2glass, 0);
5941
5942   moth->AddNode(vpcon2container, 1);
5943   moth->AddNode(vpcon2container, 2, rotCableSDD);
5944
5945   //==================================
5946   //  intermediate cylinder
5947   //==================================
5948
5949   // (was fgkSDDCableDZint hardcoded)
5950   Double_t sddCableDZint = (sddConeShape->GetZ(9) - sddConeShape->GetZ(0) +
5951                             sddCylinderShape->GetDz()) - sddCableZ3;
5952
5953   TGeoTube *interCyl = new TGeoTube("sddCableInterCyl",
5954                                     pcon2container->GetRmin(1),
5955                                     pcon2container->GetRmax(1),
5956                                     sddCableDZint/2);
5957
5958   TGeoVolume *vInterCyl = new TGeoVolume("vSddCableInterCyl",
5959                                          interCyl, airSDD);
5960   vInterCyl->SetVisibility(kFALSE);
5961
5962   Double_t rmaxCylPlast = pcon2container->GetRmax(1);
5963   Double_t rminCylPlast = TMath::Sqrt(rmaxCylPlast*rmaxCylPlast -
5964                         (sectionLay3Plastic+sectionLay4Plastic)/TMath::Pi() );
5965
5966   TGeoTube *interCylPlast = new TGeoTube("sddCableInterCylPlast", rminCylPlast,
5967                                          rmaxCylPlast, sddCableDZint/2);
5968
5969   TGeoVolume *vInterCylPlast = new TGeoVolume("vSddCableInterCylPlast",
5970                                               interCylPlast, plastic);
5971   vInterCylPlast->SetLineColor(kYellow);
5972   vInterCyl->AddNode(vInterCylPlast, 0);
5973
5974   Double_t rmaxCylCu = pcon2Cu->GetRmax(3);
5975   Double_t rminCylCu = TMath::Sqrt(rmaxCylCu*rmaxCylCu -
5976                        (sectionLay3Cu+sectionLay4Cu)/TMath::Pi() );
5977
5978   TGeoTube *interCylCu = new TGeoTube("sddCableInterCylCu", rminCylCu,
5979                                       rmaxCylCu, sddCableDZint/2);
5980
5981   TGeoVolume *vInterCylCu = new TGeoVolume("vSddCableInterCylCu",
5982                                            interCylCu, copper);
5983   vInterCylCu->SetLineColor(kRed);
5984   vInterCyl->AddNode(vInterCylCu, 0);
5985
5986   Double_t rmaxCylGlass = pcon2glass->GetRmax(3);
5987   Double_t rminCylGlass = TMath::Sqrt(rmaxCylGlass*rmaxCylGlass -
5988                           (sectionLay3Glass+sectionLay4Glass)/TMath::Pi() );
5989
5990   TGeoTube *interCylGlass = new TGeoTube("sddCableInterCylGlass", rminCylGlass,
5991                                          rmaxCylGlass, sddCableDZint/2);
5992
5993   TGeoVolume *vInterCylGlass = new TGeoVolume("vSddCableInterCylGlass",
5994                                               interCylGlass,opticalFiber);
5995   vInterCylGlass->SetLineColor(kGreen);
5996   vInterCyl->AddNode(vInterCylGlass, 0);
5997
5998   moth->AddNode(vInterCyl, 1, new TGeoTranslation(0, 0,
5999                               sddCableZ3+sddCableDZint/2));
6000   moth->AddNode(vInterCyl, 2, new TGeoTranslation(0, 0,
6001                              -sddCableZ3-sddCableDZint/2));
6002
6003   //==================================
6004   // cable cone on the SSD cone
6005   //==================================
6006
6007   Double_t sddCableR4 = rmaxCylPlast;
6008   Double_t sddCableZ4 = sddCableZ3 + sddCableDZint;
6009
6010   TGeoPcon* pcon3all = CreateConeConstSection(sddCableR4, sddCableZ4,
6011                                               fgkSDDCableR5, fgkSDDCableZ5,
6012                                               sectionLay3Plastic+
6013                                               sectionLay4Plastic+
6014                                               sectionLay3Cu+sectionLay4Cu+
6015                                               sectionLay3Glass+sectionLay4Glass, 1);
6016
6017   TGeoPcon* pcon3container = new TGeoPcon(0,360,2);
6018   pcon3container->DefineSection(0, sddCableZ4, pcon3all->GetRmin(0),
6019                                                pcon3all->GetRmax(0));
6020
6021   drMax = pcon3all->GetRmax(0) - pcon3all->GetRmin(0);
6022   pcon3container->DefineSection(1, fgkSDDCableZ5, pcon3all->GetRmax(1)-drMax,
6023                                                pcon3all->GetRmax(1));
6024
6025
6026   TGeoVolume *vpcon3container = new TGeoVolume("vpcon3container",
6027                                                pcon3container, airSDD);
6028   vpcon3container->SetVisibility(kFALSE);
6029
6030   TGeoPcon* pcon3plast = CreateConeConstSection(sddCableR4, sddCableZ4,
6031                                                 fgkSDDCableR5, fgkSDDCableZ5,
6032                                                 sectionLay3Plastic+
6033                                                 sectionLay4Plastic, 3);
6034
6035   TGeoVolume *vpcon3plast = new TGeoVolume("ITScablesSDDpcon3Plast",
6036                                            pcon3plast, plastic);
6037   vpcon3plast->SetLineColor(kYellow);
6038   vpcon3container->AddNode(vpcon3plast, 0);
6039
6040   Double_t dr3a = sddCableR4 - pcon3plast->GetRmin(0);
6041   TGeoPcon* pcon3Cu = CreateConeConstSection(sddCableR4 - dr3a, sddCableZ4,
6042                                              fgkSDDCableR5 - dr3a, fgkSDDCableZ5,
6043                                              sectionLay3Cu+sectionLay4Cu, 3);
6044
6045   TGeoVolume *vpcon3Cu = new TGeoVolume("ITScablesSDDpcon3Cu",
6046                                         pcon3Cu, copper);
6047   vpcon3Cu->SetLineColor(kRed);
6048   vpcon3container->AddNode(vpcon3Cu, 0);
6049
6050   Double_t dr3b = pcon3Cu->GetRmax(0) - pcon3Cu->GetRmin(0);
6051   TGeoPcon* pcon3glass = CreateConeConstSection(sddCableR4-dr3a-dr3b, sddCableZ4,
6052                                                 fgkSDDCableR5-dr3a-dr3b, fgkSDDCableZ5,
6053                                                 sectionLay3Glass+sectionLay4Glass, 3);
6054
6055   TGeoVolume *vpcon3glass = new TGeoVolume("ITScablesSDDpcon3glass",
6056                                            pcon3glass,opticalFiber);
6057   vpcon3glass->SetLineColor(kGreen);
6058   vpcon3container->AddNode(vpcon3glass, 0);
6059
6060   moth->AddNode(vpcon3container, 1);
6061   moth->AddNode(vpcon3container, 2, rotCableSDD);
6062
6063   //==================================
6064   // cables that are grouped at the end of SSD cones
6065   //==================================
6066
6067 //  Double_t fgkSDDCableR6 = fgkSDDCableR5+9;
6068 //  Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8.8;
6069   Double_t fgkSDDCableR6 = fgkSDDCableR5+8;
6070   Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8;
6071
6072   TGeoVolumeAssembly *endConeSDDCable = new TGeoVolumeAssembly("endConeSDDCable");
6073
6074   // Add some hardcoded shifts to avoid overlaps with SSD pathc panels
6075   CreateAndInsetConeCablePart(endConeSDDCable, 20, 1*3,2*4, fgkSDDCableR5,
6076                               fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6077
6078   CreateAndInsetConeCablePart(endConeSDDCable, 50, 1*3,1*4, fgkSDDCableR5,
6079                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6080
6081   CreateAndInsetConeCablePart(endConeSDDCable, 85, 2*3,1*4, fgkSDDCableR5,
6082                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6083
6084   CreateAndInsetConeCablePart(endConeSDDCable, 95, 0*3,1*4, fgkSDDCableR5,
6085                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6086
6087   CreateAndInsetConeCablePart(endConeSDDCable, 105, 2*3,3*4, fgkSDDCableR5,
6088                               fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6089
6090   CreateAndInsetConeCablePart(endConeSDDCable, 129, 0*3,3*4, fgkSDDCableR5,
6091                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6092
6093   CreateAndInsetConeCablePart(endConeSDDCable, 176, 0*3,1*4, fgkSDDCableR5,
6094                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6095
6096   CreateAndInsetConeCablePart(endConeSDDCable, 190, 2*3,0*4, fgkSDDCableR5,
6097                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6098
6099   CreateAndInsetConeCablePart(endConeSDDCable, 210, 1*3,2*4, fgkSDDCableR5,
6100                               fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6101
6102   CreateAndInsetConeCablePart(endConeSDDCable, 230, 1*3,2*4, fgkSDDCableR5,
6103                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6104
6105   CreateAndInsetConeCablePart(endConeSDDCable, 277, 2*3,2*4, fgkSDDCableR5,
6106                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6107
6108   CreateAndInsetConeCablePart(endConeSDDCable, 306, 1*3,1*4, fgkSDDCableR5,
6109                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6110
6111   CreateAndInsetConeCablePart(endConeSDDCable, 353, 1*3,3*4, fgkSDDCableR5,
6112                               fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6113
6114   moth->AddNode(endConeSDDCable, 1, 0);
6115
6116   TGeoRotation* reflect = new TGeoRotation("reflectEndConeSDDCable");
6117   reflect->ReflectZ(kTRUE);
6118   moth->AddNode(endConeSDDCable, 2, reflect);
6119
6120
6121   return;
6122 }