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