//*************************************************************************
+//
// SDD geometry, based on ROOT geometrical modeler
//
+//
+// This geometry has no dependence with aliroot, you can run it with root
+// only, provided that the AliITSv11GeomCable classes are also compiled
+//
// Ludovic Gaudichet gaudichet@to.infn.it
//*************************************************************************
+// $Id$
+
// General Root includes
-//#include <Riostream.h>
#include <TMath.h>
// Root Geometry includes
#include <TGeoCompositeShape.h>
#include <TGeoMatrix.h>
#include <TGeoNode.h>
+#include <TGeoPcon.h>
#include "AliITSgeom.h"
#include "AliITSgeomSDD.h"
#include "AliITSv11GeometrySDD.h"
#include "AliITSv11GeomCableFlat.h"
#include "AliITSv11GeomCableRound.h"
-#include "TList.h"
const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName3 = "ITSsddSensitivL3";
const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName4 = "ITSsddSensitivL4";
const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX = 10 *fgkmm;
const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY = 6.5 *fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 145.*fgkmm; // not min! Rmin virtual tube
-const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 205.*fgkmm; // not min! Rmax virtual tube
+const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 145.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 200.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLay3Length = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength = 524.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm;
const Int_t AliITSv11GeometrySDD::fgkLay3Nladd = 14;
const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH = 7.5*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 220.*fgkmm; // not min! Rmin virtual tube
-const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 290.*fgkmm; // not min! Rmax virtual tube
+const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 235.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 286.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLay4Length = (671.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength = 671.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm;
const Int_t AliITSv11GeometrySDD::fgkLay4Nladd = 22;
const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH = 7.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay3 = fgkLay3DetShortRadius;
+const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay4 = fgkLay4DetShortRadius;
+const Double_t AliITSv11GeometrySDD::fgkDistEndLaddCardsLadd = 0.*fgkmm;
+
//hybrid
const Double_t AliITSv11GeometrySDD::fgkHybridAngle = 46; // approx !!!
// Origine taken at the hybrid corner :
const Double_t AliITSv11GeometrySDD::fgkWaferLength = 87.6 *fgkmm;
const Double_t AliITSv11GeometrySDD::fgkWaferThickSens = 299.8*fgkmu;
const Double_t AliITSv11GeometrySDD::fgkWaferWidthSens = 70.17*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkWaferLengthSens = 74.97*fgkmm;
+// 256 anodes times 294 microns of pitch
+const Double_t AliITSv11GeometrySDD::fgkWaferLengthSens = 256*294*fgkmicron;
const Double_t AliITSv11GeometrySDD::fgkDigitCablWidth = 18.4*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkDigitCablAlThick = (30+30*8./10.)*fgkmicron; // will probably change
const Double_t AliITSv11GeometrySDD::fgkRubyZladd4 = 325*fgkmm;
// the stesalite ladder foot at its end
-const Double_t AliITSv11GeometrySDD::fgkLadFoot_X = 60.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadFoot_Z = 20.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadFoot_Y = 8.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadFootX = 60.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadFootZ = 20.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadFootY = 8.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLadFootMiddleY = 4.5*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadBox1_X = 23.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadFingerPrint_X = 6.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadFingerPrint_Y = 1.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadBox1X = 23.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintX = 6.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintY = 1.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintBorder = 4.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleZ = 8.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleX = 9.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkScrewM4diam = 4.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkRubyScrewShiftToCenterY = 0.1;
-const Double_t AliITSv11GeometrySDD::fgkRubyHoleDiam = 0.5;
+const Double_t AliITSv11GeometrySDD::fgkRubyHoleDiam = 0.5;
-// the end ladder cooling pipe and its heat exchanger
+// the U cooling pipe and its heat exchanger in end-ladder cards system
const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay3 = 138*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay4 = 150*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUwidth = 59*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkEndLadPipeInnerDiam = 2.8*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkEndLadPipeOuterDiam = 3.*fgkmm;
//--- The al body of the cooling syst.of the heat exchanger :
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3 = 112.*fgkmm; //
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4 = 125.*fgkmm; //
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX = 4.75*fgkmm; // the arms of the U cooling tube
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY = 6.8*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY = 1.03*fgkmm; // shift in Y of the arms from the axis
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX = 0.125*fgkmm; // shift in X of the arms from the axis
-const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos = 8.9*fgkmm; //
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3 = 112.*fgkmm; //
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4 = 125.*fgkmm; //
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX = 4.75*fgkmm; // the arms of the U cooling tube
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY = 6.8*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY = 1.03*fgkmm; // shift in Y of the arms from the axis
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX = 0.125*fgkmm;// shift in X of the arms from the axis
+const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos = 8.9*fgkmm; //
// LV card :
-const Double_t AliITSv11GeometrySDD::fgkLVcard_X = 26.525*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcard_Y = 44.95*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcard_Z = 1.*fgkmm; // all except Cu layer //???
-const Double_t AliITSv11GeometrySDD::fgkLVcard_CuZ = 0.1*fgkmm; //???
-
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_X = 16.525*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_Y = 10.8*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_Z = 3.5*fgkmm; // all except si layer //???
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_SiZ = 0.2*fgkmm; //???????????????????????????????????????????????????
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_PosX = 13.*fgkmm; //19.95*fgkmm; ???
-const Double_t AliITSv11GeometrySDD::fgkLVChip0_PosY = 10.3*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_X = 6.00*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_Y = 6.00*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_Z = 1*fgkmm; // ???
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_SiZ = 0.2*fgkmm; // ???
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_PosX = 18.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip1_PosY = 27.6*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_X = 6.00*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_Y = 6.00*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_Z = 1*fgkmm; // ???
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_SiZ = 0.2*fgkmm; //???
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_PosX = 18.0*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip2_PosY = 39.0*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_X = 4.01*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_Y = 4.01*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_Z = 1*fgkmm; // ???
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_SiZ = 0.2*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_PosX = 20.7*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVChip3_PosY = 21.4*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVcool_X1 = 17.25*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcool_Y1 = 8.7*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcool_Z1 = 1.*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVcool_X2 = 3.5*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcool_Y2 = 8.7*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcool_Z2 = 2.3*fgkmm;
-
-const Double_t AliITSv11GeometrySDD::fgkLVcool_X3 = 4.75*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLVcool_Y3 = 3.1*fgkmm; //+0.1=glue
+const Double_t AliITSv11GeometrySDD::fgkLVcardX = 26.525*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcardY = 44.95*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcardZ = 1.*fgkmm; // all except Cu layer //???
+const Double_t AliITSv11GeometrySDD::fgkLVcardCuZ = 0.1*fgkmm; //???
+
+const Double_t AliITSv11GeometrySDD::fgkLVChip0X = 16.525*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip0Y = 10.8*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip0Z = 3.5*fgkmm; // all except si layer //???
+const Double_t AliITSv11GeometrySDD::fgkLVChip0SiZ = 0.2*fgkmm; //???????????????????????????????????????????????????
+const Double_t AliITSv11GeometrySDD::fgkLVChip0PosX = 13.*fgkmm; //19.95*fgkmm; ???
+const Double_t AliITSv11GeometrySDD::fgkLVChip0PosY = 10.3*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVChip1X = 6.00*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip1Y = 6.00*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip1Z = 1*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkLVChip1SiZ = 0.2*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkLVChip1PosX = 18.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip1PosY = 27.6*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVChip2X = 6.00*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip2Y = 6.00*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip2Z = 1*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkLVChip2SiZ = 0.2*fgkmm; //???
+const Double_t AliITSv11GeometrySDD::fgkLVChip2PosX = 18.0*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip2PosY = 39.0*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVChip3X = 4.01*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip3Y = 4.01*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip3Z = 1*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkLVChip3SiZ = 0.2*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip3PosX = 20.7*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVChip3PosY = 21.4*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVcoolX1 = 17.25*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcoolY1 = 8.7*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcoolZ1 = 1.*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVcoolX2 = 3.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcoolY2 = 8.7*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcoolZ2 = 2.3*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkLVcoolX3 = 4.75*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLVcoolY3 = 3.1*fgkmm; //+0.1=glue
const Double_t AliITSv11GeometrySDD::fgkLVcoolPosY = 6.5*fgkmm;
// HV card :
const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Z = 7.2*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkHVCardCoolDY = 6.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX1 = 19.5*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY1 = 2*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX2 = 35.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY2 = 3.9*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ = 17.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppAngle = 45;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX3 = 4.5*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY3 = 3.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ3 = 12.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX1 = 19.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY1 = 2*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX2 = 35.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY2 = 3.9*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ = 17.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppAngle = 45;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX3 = 4.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY3 = 3.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ3 = 12.*fgkmm;
const Double_t AliITSv11GeometrySDD::fgkCarlosSuppTopLen = 8.65*fgkmm;
+// screws fixing boards to the end-ladder on the U tube
+const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadR = 1.85*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadH = 1.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkLittleScrewR = 0.7*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkShiftLittleScrewLV = 3*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkLittleLVScrewHeadR = 1.2*fgkmm; // ???
+
+// CARLOS board
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardX1 = (25.50+28.50)*fgkmm; // length (first part of Carlos card)
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardY1 = 1.6*fgkmm; // thickness
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ1 = 40.8*fgkmm; // width
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardCuY = 0.1*fgkmm; // thickness of Cu layer (strips)
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardX2 = 25.50*fgkmm; // length (2nd part of Carlos card)
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ2 = 8.20*fgkmm; // width
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardChipSiThick = 0.1*fgkmm; // ??? idem for all chips ???
+const Double_t AliITSv11GeometrySDD::fgkCarlosCardShift = 9*fgkmm; // ??? shift in z w.r.t. heat bridge
+
+// size and position of various chips on carlos end-ladder board
+const Double_t AliITSv11GeometrySDD::fgkCarlosU1X = 13*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU1Y = 1.68*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU1Z = 13*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU1posX = 18.4*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU1posZ = -7.2*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosU2X = 13.75*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU2Y = 1.60*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU2Z = 13.85*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU2posX = -0.375*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU2posZ = -9.725*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosU3X = 5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU3Y = 1.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU3Z = 5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU3posX = 6.4*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU3posZ = 9.9*fgkmm;
+
+// U4 like U3
+const Double_t AliITSv11GeometrySDD::fgkCarlosU4posX = -12*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU4posZ = 3.6*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosU17X = 16*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU17Y = 3.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU17Z = 10.9*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU17posX = -17.84*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU17posZ = -10.95*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosU35X = 4*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU35Y = 1.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU35Z = 4*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU35posX = -21.6*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU35posZ = 2.3*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosU36X = 6*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU36Y = 1.*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU36Z = 6*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU36posX = -21.6*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosU36posZ = 9.6*fgkmm;
+
+const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1X = 8*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Y = 1.7*fgkmm; // look thicker than design number (0.7) ! ???
+const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Z = 3.7*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posX = -12*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posZ = 10.6*fgkmm;
+
+// distance from the heat bridge center to the card center :
+const Double_t AliITSv11GeometrySDD::fgkCarlosCard2HeatBridge = fgkCarlosSuppY2/2+fgkCarlosCardY1/2+fgkCarlosU1Y+0.1*fgkmm;
+
+// some pieces at the end of the carbon fiber ladder
+ const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay3Len = 467.*fgkmm; // ???
+ const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay4Len = 616.*fgkmm; // ???
+ const Double_t AliITSv11GeometrySDD::fgkHVguideX1 = 42.5*fgkmm;
+ const Double_t AliITSv11GeometrySDD::fgkHVguideY1 = 7.*fgkmm;
+ const Double_t AliITSv11GeometrySDD::fgkHVguideZ1 = 10.*fgkmm;
+ const Double_t AliITSv11GeometrySDD::fgkHVguideZ2 = 6.*fgkmm;
+ const Double_t AliITSv11GeometrySDD::fgkHVguideDX = -8.5*fgkmm;
+ const Double_t AliITSv11GeometrySDD::fgkHVguideSuppFullZ = 37.5*fgkmm;
+
+// Cooling connector between phynox and plastic cooling water tubes
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeRmin = 1 *fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR1 = 2.5*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL1 = 3.*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR2 = 3.5*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL2 = 2.*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR3 = 3.*fgkmm; // ???
+const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL3 = 5 *fgkmm; // ???
+
+
+// parameters for coding SDD cables on SDD and SSD cones
+const Double_t AliITSv11GeometrySDD::fgkSectionCuPerMod = 3*2*0.006 + 3*2*0.0005 + 2*0.002;
+// copper : LV + signal + HV(HV ???)
+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)
+ - fgkSectionCuPerMod);
+
+const Double_t AliITSv11GeometrySDD::fgkSectionGlassPerMod = 3*0.006; // ???
+// (sections are given in cm square)
+const Double_t AliITSv11GeometrySDD::fgkCableBendRatio = 1.3; // ??? this factor account for the bending of cables
+
+const Double_t AliITSv11GeometrySDD::fgkConeSDDr1 = 11.87574*fgkcm;
+const Double_t AliITSv11GeometrySDD::fgkConeSDDr2 = 26.07574*fgkcm;
+const Double_t AliITSv11GeometrySDD::fgkConeSDDz1 = 3.36066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
+const Double_t AliITSv11GeometrySDD::fgkConeSDDz2 = 17.56066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
+// These last parameters come from cone's code and define the slope
+// and position of the SDD cone end. For some unknown reason, this doesn't
+// allow to stick on the SDD cone. This has to be checked when a correct
+// version of the cone is available ... For now 'm applying some approximative
+// corrections
+
+const Double_t AliITSv11GeometrySDD::fgkSDDCableR1 = 16*fgkcm; // ??? // part 1 of "cable cone"
+const Double_t AliITSv11GeometrySDD::fgkSDDCableR2 = 23*fgkcm; // ??? // part 1/2 of "cable cone"
+const Double_t AliITSv11GeometrySDD::fgkSDDCableR3 = 26*fgkcm; // ??? // part 2 of "cable cone"
+
+const Double_t AliITSv11GeometrySDD::fgkSDDCableDZint = 3.5*fgkcm;
+const Double_t AliITSv11GeometrySDD::fgkSDDCableR5 = 37*fgkcm; // third part of "cable cone"
+const Double_t AliITSv11GeometrySDD::fgkSDDCableZ5 = 65*fgkcm; // third part of "cable cone"
+
+
fSDDsensor4(0),
fBaseThermalBridge(0),
fHybrid(0),
+ fLadderFoot(0),
+ fCardLVR(0),
+ fCardLVL(0),
+ fCardHV(0),
+ fCardCarlos(0),
+ fRaccordoL(0),
fDigitCableLay3A(0),
fDigitCableLay3B(0),
fDigitCableLay4A(0),
fSDDsensor4(0),
fBaseThermalBridge(0),
fHybrid(0),
+ fLadderFoot(0),
+ fCardLVR(0),
+ fCardLVL(0),
+ fCardHV(0),
+ fCardCarlos(0),
+ fRaccordoL(0),
fDigitCableLay3A(0),
fDigitCableLay3B(0),
fDigitCableLay4A(0),
fSDDsensor4(s.fSDDsensor4),
fBaseThermalBridge(s.fBaseThermalBridge),
fHybrid(s.fHybrid),
+ fLadderFoot(s.fLadderFoot),
+ fCardLVR(s.fCardLVR),
+ fCardLVL(s.fCardLVL),
+ fCardHV(s.fCardHV),
+ fCardCarlos(s.fCardCarlos),
+ fRaccordoL(s.fRaccordoL),
fDigitCableLay3A(s.fDigitCableLay3A),
fDigitCableLay3B(s.fDigitCableLay3B),
fDigitCableLay4A(s.fDigitCableLay4A),
fBaseThermalBridge = CreateBaseThermalBridge();
fHybrid = CreateHybrid(0);
-
TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); //ITSsddCarbonM55J
- TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$");//ITSsddKAPTON_POLYCH2
- TGeoMedium *alSDD = GetMedium("AL$"); //ITSal
+ TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$");//ITSsddKAPTON_POLYCH2
+ TGeoMedium *alSDD = GetMedium("AL$"); //ITSal
+ TGeoMedium *stainless = GetMedium("INOX$"); // for screws, what is the material ???????????
+ TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
+ TGeoMedium *raccordMedium = GetMedium("INOX$"); // ??? material of raccordo ???
//********************************************************************
// pieces of the carbon fiber structure
TMath::Tan(halfTheta),
fgkLadderBeamRadius/2. - dy,
-3*fgkSegmentLength/8, beamRot1);
- beamTransf[1] = new TGeoCombiTrans(*beamTransf[0]);
+
+ beamTransf[1] = new TGeoCombiTrans( 0.5*triangleHeight*
+ TMath::Tan(halfTheta),
+ fgkLadderBeamRadius/2. - dy,
+ -3*fgkSegmentLength/8, beamRot1);
AddTranslationToCombiTrans(beamTransf[1], 0, 0, fgkSegmentLength/2);
beamTransf[2] = new TGeoCombiTrans(0.5*triangleHeight*
TMath::Tan(halfTheta),
fgkLadderBeamRadius/2. - dy,
-fgkSegmentLength/8, beamRot2);
- beamTransf[3] = new TGeoCombiTrans(*beamTransf[2]);
+
+ beamTransf[3] = new TGeoCombiTrans(0.5*triangleHeight*
+ TMath::Tan(halfTheta),
+ fgkLadderBeamRadius/2. - dy,
+ -fgkSegmentLength/8, beamRot2);
AddTranslationToCombiTrans(beamTransf[3], 0, 0, fgkSegmentLength/2);
beamTransf[4] = new TGeoCombiTrans(-0.5*triangleHeight*
TMath::Tan(halfTheta),
fgkLadderBeamRadius/2. - dy,
-3*fgkSegmentLength/8, beamRot3);
- beamTransf[5] = new TGeoCombiTrans(*beamTransf[4]);
+
+ beamTransf[5] = new TGeoCombiTrans(-0.5*triangleHeight*
+ TMath::Tan(halfTheta),
+ fgkLadderBeamRadius/2. - dy,
+ -3*fgkSegmentLength/8, beamRot3);
AddTranslationToCombiTrans(beamTransf[5], 0, 0, fgkSegmentLength/2);
beamTransf[6] = new TGeoCombiTrans(-0.5*triangleHeight*
// coding efforts ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// The only thing to do is to change the names and put the correct total
// thicknesses
+
+ // some transformations and volumes used in several places
+ fCommonTr[0] = new TGeoRotation("CarlosSuppRotN",
+ 0, -fgkCarlosSuppAngle, 0);
+
+ TGeoTube *littleScrewHead = new TGeoTube("littleScrewHead", 0, fgkLittleScrewHeadR,
+ fgkLittleScrewHeadH/2);
+ fCommonVol[0] = new TGeoVolume("vLittleScrewHead",
+ littleScrewHead, stainless);
+ fCommonVol[0]->SetLineColor(kGray);
+
+ fLadderFoot = CreateLadderFoot();
+ CreateLVCard();
+ fCardHV = CreateHVCard(0);
+ fCardCarlos = CreateCarlosCard(0);
+
+ //==================
+ // link beteen phynox and plastic cooling tubes
+ //==================
+
+ fRaccordoL = new TGeoVolumeAssembly("RaccordoL");
+ Double_t fullRacLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
+ TGeoTube *waterRac = new TGeoTube("waterRac", 0, fgkConnectorCoolTubeRmin, fullRacLen/2);
+ TGeoVolume * vwaterRac = new TGeoVolume("vwaterRac", waterRac, coolerMediumSDD);
+ vwaterRac->SetLineColor(kBlue);
+
+ TGeoTube *tube1Rac = new TGeoTube("tube1Rac", fgkConnectorCoolTubeRmin,
+ fgkConnectorCoolTubeR1, fgkConnectorCoolTubeL1/2);
+ TGeoTube *tube2Rac = new TGeoTube("tube2Rac", fgkConnectorCoolTubeRmin,
+ fgkConnectorCoolTubeR2, fgkConnectorCoolTubeL2/2);
+ TGeoTube *tube3Rac = new TGeoTube("tube3Rac", fgkConnectorCoolTubeRmin,
+ fgkConnectorCoolTubeR3, fgkConnectorCoolTubeL3/2);
+ TGeoVolume * vtube1Rac = new TGeoVolume("vtube1Rac", tube1Rac, raccordMedium);
+ TGeoVolume * vtube2Rac = new TGeoVolume("vtube2Rac", tube2Rac, raccordMedium);
+ TGeoVolume * vtube3Rac = new TGeoVolume("vtube3Rac", tube3Rac, raccordMedium);
+ vtube1Rac->SetLineColor(kGray);
+ vtube2Rac->SetLineColor(kGray);
+ vtube3Rac->SetLineColor(kGray);
+
+ TGeoTranslation *trTube1Rac = new TGeoTranslation("trTube1Rac",0,0,
+ -fullRacLen/2+fgkConnectorCoolTubeL1/2);
+ TGeoTranslation *trTube2Rac = new TGeoTranslation("trTube2Rac",0,0,
+ (-fullRacLen/2+fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2/2));
+ TGeoTranslation *trTube3Rac = new TGeoTranslation("trTube3Rac",0,0,
+ (-fullRacLen/2+fgkConnectorCoolTubeL1+
+ fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3/2));
+ fRaccordoL->AddNode(vwaterRac, 1,0);
+ fRaccordoL->AddNode(vtube1Rac, 1,trTube1Rac);
+ fRaccordoL->AddNode(vtube2Rac, 1,trTube2Rac);
+ fRaccordoL->AddNode(vtube3Rac, 1,trTube3Rac);
}
// moth->AddNode(fPinSupport, 1, 0);
// moth->AddNode(fCoolPipeSupportL, 1, 0);
- //moth->AddNode(fSDDsensor3, 1, 0);
- // moth->AddNode(fSDDsensor4, 1, 0);
+ // moth->AddNode(fSDDsensor3, 1, 0);
+ // moth->AddNode(fSDDsensor4, 1, 0);
// moth->AddNode(fBaseThermalBridge, 1, 0);
// moth->AddNode(fHybrid,100,0);
+ // moth->AddNode(fLadderFoot,1,0);
+ //moth->AddNode(fCardLVL,1,0);
+ //moth->AddNode(fCardLVR,1,0);
-
-// TGeoVolumeAssembly* seg = CreateLadderSegment( 3, 0);
-// moth->AddNode(seg, 1, 0);
-
+ TGeoVolume* seg = CreateLadderSegment( 3, 0);
+ moth->AddNode(seg, 1, 0);
// TGeoVolumeAssembly *lay3Ladder = CreateLadder(3);
// moth->AddNode(lay3Ladder, 1, 0);
- TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
- moth->AddNode(lay3Detectors, 1, 0);
+// TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
+// moth->AddNode(lay3Detectors, 1, 0);
// TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
// moth->AddNode(lay3Detectors, 1, 0);
-// TGeoVolumeAssembly *endLadder = CreateEndLadder( 3 );
+// TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 );
// moth->AddNode(endLadder, 1, 0);
+// TGeoVolumeAssembly *highVCard = CreateHVCard( 4 );
+// moth->AddNode(highVCard, 1, 0);
+
+// TGeoVolumeAssembly *supportRing = CreateSupportRing( 4 );
+// moth->AddNode(supportRing, 1, 0);
+
+// TGeoVolume *endLadderCards = CreateEndLadderCardsV( 4 );
+// moth->AddNode(endLadderCards, 1, 0);
// TGeoVolumeAssembly *carlosCard = CreateCarlosCard( 4 );
// moth->AddNode(carlosCard, 1, 0);
-// TGeoVolumeAssembly *highVCard = CreateHVCard( 4 );
-// moth->AddNode(highVCard, 1, 0);
-// TGeoVolumeAssembly *endLadderCards = CreateEndLadderCards( 4 );
-// moth->AddNode(endLadderCards, 1, 0);
-// TGeoVolumeAssembly *supportRing = CreateSupportRing( 4 );
-// moth->AddNode(supportRing, 1, 0);
+ /*
+ //==================================
+ //--- test of flat cable curvature
+ //==================================
+
+ double angle = 90;
+ AliITSv11GeomCableFlat cable("test", 3, 0.3);
+ cable.SetNLayers(1);
+ cable.SetNLayers(2);
+ cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
+ cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
+ cable.SetInitialNode(endLadderCards);
+
+ Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
+
+ p1[0] = -3;
+ p1[1] = 1;
+ p1[2] = 10;
+
+ p2[0] = 0;
+ p2[1] = 1;
+ p2[2] = 10;
+ cable.AddCheckPoint(endLadderCards, 0, p1, vX);
+ cable.AddCheckPoint(endLadderCards, 1, p2, vX);
+ cable.CreateAndInsertBoxCableSegment(1,angle);
+
+ Double_t p3[3], p4[3];
+
+ p3[0] = 2;
+ p3[1] = 3;
+ p3[2] = 10;
+ cable.AddCheckPoint(endLadderCards, 2, p3, vY);
+ cable.CreateAndInsertCableCylSegment(2,angle);
+
+ p4[0] = 2;
+ p4[1] = 6;
+ p4[2] = 10;
+ cable.AddCheckPoint(endLadderCards, 3, p4, vY);
+ cable.CreateAndInsertCableSegment(3,angle);
+ */
}
return;
};
-
TGeoMedium *airSDD = GetMedium("SDD AIR$");
fMotherVol = moth;
if (iLadd%2 != 0)
minRadiusLadBox = fLay3LaddLongRadius-fLay3LadderUnderSegDH;
minRadiusLadBox += ((TGeoBBox*)lay3Ladder->GetShape())->GetDY();
- TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
- 0, ladderPhi, kTRUE);
+ TGeoCombiTrans *ctLadd;
+ //=============================================================
+ //
+ // Special modification for ladder 2 of layer 3:
+ // It has been inverted (pi rotation around y axis)
+ //
+ //=============================================================
+ if (iLadd != 2)
+ ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
+ 0, ladderPhi, kTRUE);
+ else
+ ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
+ 0, ladderPhi, kFALSE);
virtualLayer3->AddNode(lay3Ladder, iLadd, ctLadd);
///////////////////////////////////////////////////
sprintf(rotName, "ITSsddLay3DetBox%i",iLadd);
Double_t minRadiusDetBox = fgkLay3DetShortRadius;
if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
minRadiusDetBox += detectorsThick/2;
- TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
- 0, ladderPhi, kTRUE);
+ TGeoCombiTrans *ctDet;
+ if (iLadd != 2)
+ ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
+ 0, ladderPhi, kTRUE);
+ else
+ ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
+ 0, ladderPhi, kFALSE);
+
virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet);
///////////////////////////////////////////////////
}
+ /*
//====================================
// Then the forward rapidity pieces
// (cooling, Carlos, LV, HV ...)
//====================================
- Double_t fgkForwardLay3Length = 200*fgkmm; // this has to be tune !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- Double_t fgkForwardLay3Rmin = fgkLay3Rmin-10*fgkmm;
- Double_t fgkForwardLay3Rmax = fgkLay3Rmax;
+ Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm; // this has to be tune
+ Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
+ Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
fgkForwardLay3Rmin, fgkForwardLay3Rmax,
fgkForwardLay3Length/2.);
+
+// TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
+// // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+// virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
+
+
TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
virtualForward3Shape, airSDD);
TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
virtualForward3Shape, airSDD);
+// TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+// TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
fgkLay3Length/2+fgkForwardLay3Length/2);
TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
}
+ */
+
if(GetDebug(1)) {
virtualLayer3->CheckOverlaps(0.01);
- virtualForward3Pos->CheckOverlaps(0.01);
- virtualForward3Neg->CheckOverlaps(0.01);
+ //virtualForward3Pos->CheckOverlaps(0.01);
+ //virtualForward3Neg->CheckOverlaps(0.01);
}
virtualLayer3->SetVisibility(kFALSE);
- virtualForward3Pos->SetVisibility(kFALSE);
- virtualForward3Neg->SetVisibility(kFALSE);
+ //virtualForward3Pos->SetVisibility(kFALSE);
+ //virtualForward3Neg->SetVisibility(kFALSE);
+
moth->AddNode(virtualLayer3, 1, 0);
- moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
- moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
+ //moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
+ //moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
}
+// //________________________________________________________________________
+// void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
+// //
+// // Insert the forward pieces of layer 3 in the mother volume.
+// // (cooling, Carlos, LV, HV ...)
+// //
+
+// if (! moth) {
+// printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
+// return;
+// };
+
+// TGeoMedium *airSDD = GetMedium("SDD AIR$");
+
+// if (! fSDDsensor3) CreateBasicObjects();
+
+// Double_t dPhi = 360./fgkLay3Nladd;
+// Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
+// Int_t iLaddMin = 0;
+// Int_t iLaddMax = fgkLay3Nladd;
+// if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
+// iLaddMin = fAddOnlyLadder3min;
+// iLaddMax = fAddOnlyLadder3max+1;
+// };
+// char rotName[30];
+
+
+// //=================
+
+// Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm; // this has to be tune
+// Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
+// Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
+
+// TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
+// TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
+// fgkForwardLay3Rmin, fgkForwardLay3Rmax,
+// fgkForwardLay3Length/2.);
+
+// // TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
+// // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+// // virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
+
+
+// TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
+// virtualForward3Shape, airSDD);
+// TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
+// virtualForward3Shape, airSDD);
+// // TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+// // TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
+// TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
+// fgkLay3Length/2+fgkForwardLay3Length/2);
+// TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
+// -fgkLay3Length/2-fgkForwardLay3Length/2);
+
+// for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+// Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
+// Double_t minRadiusDetBox = fgkLay3DetShortRadius;
+// if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
+// minRadiusDetBox += detectorsThick/2;
+
+// sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
+
+// TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+// -fgkForwardLay3Length/2, ladderPhi, kTRUE);
+// TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+// fgkForwardLay3Length/2, ladderPhi, kFALSE);
+
+// virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
+// virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
+// }
+
+// if(GetDebug(1)) {
+// virtualForward3Pos->CheckOverlaps(0.01);
+// virtualForward3Neg->CheckOverlaps(0.01);
+// }
+
+// virtualForward3Pos->SetVisibility(kFALSE);
+// virtualForward3Neg->SetVisibility(kFALSE);
+
+// moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
+// moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
+// }
+
+
+
+//________________________________________________________________________
+void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
+ //
+ // Insert the end-ladder of layer 3 in the mother volume.
+ // (cooling, Carlos, LV, HV ...)
+ //
+
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
+ return;
+ };
+
+ if (! fSDDsensor3) CreateBasicObjects();
+
+ Int_t iLaddMin = 0;
+ Int_t iLaddMax = fgkLay3Nladd;
+ if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
+ iLaddMin = fAddOnlyLadder3min;
+ iLaddMax = fAddOnlyLadder3max+1;
+ };
+
+ TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
+ TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
+
+ char rotName[30];
+ Double_t dPhi = 360./fgkLay3Nladd;
+ TGeoVolume* lay3EndLadder = CreateEndLadderCardsV(3);
+
+ for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+ Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
+ Double_t dR = 0;
+ if (iLadd%2 != 0) dR = fgkLay3DetLongRadius-fgkLay3DetShortRadius;
+
+ sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
+
+ TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
+ fgkLay3Length/2, ladderPhi, kTRUE);
+ TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
+ -fgkLay3Length/2, ladderPhi, kFALSE);
+
+ virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
+ virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
+ }
+
+ if(GetDebug(1)) {
+ virtualForward3Pos->CheckOverlaps(0.01);
+ virtualForward3Neg->CheckOverlaps(0.01);
+ }
+
+ moth->AddNode(virtualForward3Pos, 1);
+ moth->AddNode(virtualForward3Neg, 1);
+}
+
//________________________________________________________________________
void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
//
///////////////////////////////////////////////////
}
+ /*
//====================================
// Then the pieces at forward rapidity
// (cooling, Carlos, LV, HV ...)
//====================================
- Double_t fgkForwardLay4Length = 200*fgkmm; // this has to be tuned !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- Double_t fgkForwardLay4Rmin = fgkLay4Rmin-10*fgkmm;
- Double_t fgkForwardLay4Rmax = fgkLay4Rmax;
+ Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned
+ Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
+ Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
virtualForward4Shape, airSDD);
TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
virtualForward4Shape, airSDD);
+// TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+// TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
fgkLay4Length/2+fgkForwardLay4Length/2);
TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
}
+ */
if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01);
virtualLayer4->SetVisibility(kFALSE);
- virtualForward4Pos->SetVisibility(kFALSE);
- virtualForward4Neg->SetVisibility(kFALSE);
+ //virtualForward4Pos->SetVisibility(kFALSE);
+ //virtualForward4Neg->SetVisibility(kFALSE);
moth->AddNode(virtualLayer4,1,0);
- moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
- moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+ //moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
+ //moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+}
+
+
+// //________________________________________________________________________
+// void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
+// //
+// // Insert the layer 4 in the mother volume. This is a virtual volume
+// // containing ladders of layer 4 and the supporting rings
+// // (cooling, Carlos, LV, HV ...)
+// //
+
+// if (! moth) {
+// printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
+// return;
+// };
+
+// TGeoMedium *airSDD = GetMedium("SDD AIR$");
+
+// if (! fSDDsensor3) CreateBasicObjects();
+
+// Double_t dPhi = 360./fgkLay4Nladd;
+// Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
+
+// // placing virtual ladder and detectors volumes following ladder
+// // ordering convention
+// char rotName[20];
+// Int_t iLaddMin = 0;
+// Int_t iLaddMax = fgkLay4Nladd;
+// if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
+// iLaddMin = fAddOnlyLadder4min;
+// iLaddMax = fAddOnlyLadder4max+1;
+// }
+
+// //=================
+// Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned
+// Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
+// Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
+
+// TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
+// TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
+// fgkForwardLay4Rmin, fgkForwardLay4Rmax,
+// fgkForwardLay4Length/2.);
+// TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
+// virtualForward4Shape, airSDD);
+// TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
+// virtualForward4Shape, airSDD);
+// // TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+// // TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
+// TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
+// fgkLay4Length/2+fgkForwardLay4Length/2);
+// TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
+// -fgkLay4Length/2-fgkForwardLay4Length/2);
+
+// for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+// Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
+// Double_t minRadiusDetBox = fgkLay4DetShortRadius;
+// if (iLadd%2 != 0)
+// minRadiusDetBox = fgkLay4DetLongRadius;
+// minRadiusDetBox += detBoxThickness/2;
+
+// sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
+
+// TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+// -fgkForwardLay4Length/2, ladderPhi, kTRUE);
+// TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
+// fgkForwardLay4Length/2, ladderPhi, kFALSE);
+// virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
+// virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
+// }
+
+// virtualForward4Pos->SetVisibility(kFALSE);
+// virtualForward4Neg->SetVisibility(kFALSE);
+
+// moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
+// moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
+// }
+
+
+//________________________________________________________________________
+void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
+ //
+ // Insert the end-ladder of layer 4 in the mother volume.
+ // (cooling, Carlos, LV, HV ...)
+ //
+
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
+ return;
+ };
+
+ if (! fSDDsensor3) CreateBasicObjects();
+
+ // placing virtual ladder and detectors volumes following ladder
+ // ordering convention
+ Int_t iLaddMin = 0;
+ Int_t iLaddMax = fgkLay4Nladd;
+ if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
+ iLaddMin = fAddOnlyLadder4min;
+ iLaddMax = fAddOnlyLadder4max+1;
+ }
+
+ TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
+ TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
+
+ char rotName[30];
+ Double_t dPhi = 360./fgkLay4Nladd;
+ TGeoVolume* lay4EndLadder = CreateEndLadderCardsV(4);
+
+ for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
+
+ Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
+ Double_t dR = 0;
+ if (iLadd%2 != 0)
+ dR = fgkLay4DetLongRadius-fgkLay4DetShortRadius;
+
+ sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
+
+ TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
+ fgkLay4Length/2, ladderPhi, kTRUE);
+ TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
+ -fgkLay4Length/2, ladderPhi, kFALSE);
+ virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
+ virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2, ctEndLaddNeg);
+ }
+
+ moth->AddNode(virtualForward4Pos, 1);
+ moth->AddNode(virtualForward4Neg, 1);
}
//________________________________________________________________________
TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
//
- // return a box volume containing the CF ladder
+ // return an assembly volume containing the CF ladder
//
Int_t nDetectors = fgkLay3Ndet;
// adding segment this way to create cable points in the correct order ...
for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
- TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
+ //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
+ TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
+ fgkSegmentLength/2;
};
for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
- TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
+ TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
+ //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
+ fgkSegmentLength/2;
for (Int_t iPt=1; iPt<digitCableA[iSegment].GetNCheckPoints(); iPt++ ) {
Double_t rotation = 0;
- if (iPt>1) rotation = 90-fgkHybridAngle;
- digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
+ if (iPt>1) {
+ rotation = 90-fgkHybridAngle;
+ digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
+ } else
+ digitCableA[iSegment].CreateAndInsertCableSegment(iPt);
+
};
for (Int_t iPt=1; iPt<digitCableB[iSegment].GetNCheckPoints(); iPt++ ) {
Double_t rotation = 0;
- if (iPt>1) rotation = fgkHybridAngle-90;
- digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
+ if (iPt>1) {
+ rotation = fgkHybridAngle-90;
+ digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
+ } else
+ digitCableB[iSegment].CreateAndInsertCableSegment(iPt);
};
};
for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
*fgkLongHVcableSeparation;
- x1[1] = - ladderBoxDH/2;
+ // adjust where HV long cable starts in Y
+ // useful if you want to let some space for alignment
+ x1[1] = - ladderBoxDH/2 + 2*fgkmm;
x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
- (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
x3[1] = x2[1];
x2[2] = x1[2]+5*fgkmm;
x3[2] = ladderLength/2-endLength;
cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
- cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vYZ );
+ cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
- cableHV[iSegment].CreateAndInsertCableSegment(1,0);
- cableHV[iSegment].CreateAndInsertCableSegment(2,0);
+ //cableHV[iSegment].CreateAndInsertCableSegment(1,0);
+ cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45+180);
+ //cableHV[iSegment].CreateAndInsertCableSegment(2,0);
+ cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
};
vYZ[2] = -1;
for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
*fgkLongHVcableSeparation;
- x1[1] = - ladderBoxDH/2;
+ x1[1] = - ladderBoxDH/2 + 2*fgkmm; // adjust where HV long cable starts in Y
x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
- (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
x3[1] = x2[1];
x2[2] = x1[2]-5*fgkmm;
x3[2] = -ladderLength/2+endLength;
cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
- cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vYZ );
+ cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
- cableHV[iSegment].CreateAndInsertCableSegment(1,0);
- cableHV[iSegment].CreateAndInsertCableSegment(2,0);
+ cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45);
+ cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
};
};
};
//**************************************************** CC outside chips:
- // je crois qu'il n'y a pas de 2ieme couche d'alu ici ...
+ // I don't think there is a second aluminium layer here ...
for (Int_t i = 0; i<4; i++) {
char ch[20];
sprintf(ch, "ccLayerA%i", i);
return hybrid;
}
-
//________________________________________________________________________
-TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
+TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
//
- // Return a TGeoVolumeAssembly containing a segment of a ladder.
+ // Return a TGeoVolume* containing a segment of a ladder.
//
- TGeoMedium *phynoxSDD = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *phynoxSDD = GetMedium("INOX$");
TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
+ TGeoMedium *airSDD = GetMedium("SDD AIR$");
Double_t tDY = fgkLadderSegBoxDH/2; //space left on top of the ladder
Double_t segmentLength = fgkSegmentLength;
//****************************
// The segment volume
//****************************
-// TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox",
-// fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
-// fgkLadderHeight/2+fgkLadderSegBoxDH/2,
-// segmentLength/2);
-
-// TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment",
-// segBox, airSDD);
- TGeoVolumeAssembly *virtualSeg = new TGeoVolumeAssembly("ITSsddSegment");
+ // Use of TGeoVolumeAssembly increases the calculation time of overlaps and very
+ // likely slows down the transport of particles through the geometry
+
+ //TGeoVolumeAssembly *virtualSeg = new TGeoVolumeAssembly("ITSsddSegment");
+
+ TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox",
+ fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
+ fgkLadderHeight/2+fgkLadderSegBoxDH/2,
+ segmentLength/2);
+
+ TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment",
+ segBox, airSDD);
+ virtualSeg->SetVisibility(kFALSE);
//******************************
// Carbon fiber structure :
TGeoRotation *rotPS1 = new TGeoRotation("",0,-90,90);
TGeoRotation *rotPS2 = new TGeoRotation("",0,-90,-90);
+ // The use of the following constructor type allow to use rotPS1 and rotPS2
+ // (and not copy them) therefore we gain some memory
TGeoCombiTrans *transPS1 = new TGeoCombiTrans( fgkPinDYOnSensor,
- fgkLadderHeight/2.-tDY
+ fgkPinSuppHeight/2.,
sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
- TGeoCombiTrans *transPS2 = new TGeoCombiTrans(*transPS1);
+
+ TGeoCombiTrans *transPS2 = new TGeoCombiTrans( fgkPinDYOnSensor,
+ - fgkLadderHeight/2.-tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
AddTranslationToCombiTrans(transPS2, 0, 0, fgkPinPinDDXOnSensor);
- TGeoCombiTrans *transPS3 = new TGeoCombiTrans(*transPS1);
+
+ TGeoCombiTrans *transPS3 = new TGeoCombiTrans( fgkPinDYOnSensor,
+ - fgkLadderHeight/2.-tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
AddTranslationToCombiTrans(transPS3, 0, 0, -2*fgkPinDXminOnSensor);
- TGeoCombiTrans *transPS4 = new TGeoCombiTrans(*transPS3);
- AddTranslationToCombiTrans(transPS4, 0, 0, -fgkPinPinDDXOnSensor);
+
+ TGeoCombiTrans *transPS4 = new TGeoCombiTrans( fgkPinDYOnSensor,
+ - fgkLadderHeight/2.-tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
+ AddTranslationToCombiTrans(transPS4, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
TGeoCombiTrans *transPS5 = new TGeoCombiTrans( -fgkPinDYOnSensor,
- fgkLadderHeight/2. - tDY
+ fgkPinSuppHeight/2.,
sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
- TGeoCombiTrans *transPS6 = new TGeoCombiTrans(*transPS5);
+
+ TGeoCombiTrans *transPS6 = new TGeoCombiTrans( -fgkPinDYOnSensor,
+ - fgkLadderHeight/2. - tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
AddTranslationToCombiTrans(transPS6, 0, 0, fgkPinPinDDXOnSensor);
- TGeoCombiTrans *transPS7 = new TGeoCombiTrans(*transPS5);
+
+ TGeoCombiTrans *transPS7 = new TGeoCombiTrans( -fgkPinDYOnSensor,
+ - fgkLadderHeight/2. - tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
AddTranslationToCombiTrans(transPS7, 0, 0, -2*fgkPinDXminOnSensor);
- TGeoCombiTrans *transPS8 = new TGeoCombiTrans(*transPS7);
- AddTranslationToCombiTrans(transPS8, 0, 0, -fgkPinPinDDXOnSensor);
+
+ TGeoCombiTrans *transPS8 = new TGeoCombiTrans( -fgkPinDYOnSensor,
+ - fgkLadderHeight/2. - tDY
+ + fgkPinSuppHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
+ AddTranslationToCombiTrans(transPS8, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
virtualSeg->AddNode(fPinSupport, 1, transPS1);
virtualSeg->AddNode(fPinSupport, 2, transPS2);
virtualSeg->AddNode(fPinSupport, 6, transPS6);
virtualSeg->AddNode(fPinSupport, 7, transPS7);
virtualSeg->AddNode(fPinSupport, 8, transPS8);
-
- //******************************
- // Cooling pipe supports :
- //******************************
- Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
- Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
- Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
- fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
-
- Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
- (triangleHeight+triangleCPaxeDist/
+
+ TGeoMedium *pinMed = GetMedium("SDDKAPTON (POLYCH2)$"); // medium ???
+ Double_t fgkPinHeight = 4.5*fgkmm;
+ TGeoTube *pineS = new TGeoTube("ITSsddPin",0,fgkPinR,
+ fgkPinHeight/2.);
+ TGeoVolume *pineV = new TGeoVolume("ITSsddPinVol", pineS, pinMed);
+
+ TGeoCombiTrans *transPS2b = new TGeoCombiTrans( fgkPinDYOnSensor,
+ - fgkLadderHeight/2.-tDY
+ + fgkPinHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
+ AddTranslationToCombiTrans(transPS2b, 0, 0, fgkPinPinDDXOnSensor);
+ virtualSeg->AddNode(pineV, 1, transPS2b);
+
+ TGeoCombiTrans *transPS6b = new TGeoCombiTrans( -fgkPinDYOnSensor,
+ - fgkLadderHeight/2. - tDY
+ + fgkPinHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
+ AddTranslationToCombiTrans(transPS6b, 0, 0, fgkPinPinDDXOnSensor);
+ virtualSeg->AddNode(pineV, 2, transPS6b);
+
+
+ TGeoCombiTrans *transPS4b = new TGeoCombiTrans( fgkPinDYOnSensor,
+ - fgkLadderHeight/2.-tDY
+ + fgkPinHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
+ AddTranslationToCombiTrans(transPS4b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
+ virtualSeg->AddNode(pineV, 3, transPS4b);
+
+ TGeoCombiTrans *transPS8b = new TGeoCombiTrans( -fgkPinDYOnSensor,
+ - fgkLadderHeight/2. - tDY
+ + fgkPinHeight/2.,
+ sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
+ AddTranslationToCombiTrans(transPS8b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
+ virtualSeg->AddNode(pineV, 4, transPS8b);
+
+
+ //******************************
+ // Cooling pipe supports :
+ //******************************
+ Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
+ Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
+ Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
+ fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
+
+ Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
+ (triangleHeight+triangleCPaxeDist/
TMath::Sin(halfTheta)-coolPipeSuppH);
if (fAddCoolingSyst) {
TGeoRotation *rotCPS2 = new TGeoRotation("", -halfTheta*TMath::RadToDeg(), -90, 90);
-fgkLadderHeight/2. - tDY
+coolPipeSuppH+fgkLadderBeamRadius,
-segmentLength/2., rotCPS1);
- TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(*transCPS1);
+
+ TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(coolPipeSuppL,
+ -fgkLadderHeight/2. - tDY
+ +coolPipeSuppH+fgkLadderBeamRadius,
+ -segmentLength/2., rotCPS1);
AddTranslationToCombiTrans(transCPS3, 0, 0, segmentLength);
TGeoCombiTrans *transCPS2 = new TGeoCombiTrans(-coolPipeSuppL,
-fgkLadderHeight/2.- tDY
+coolPipeSuppH+fgkLadderBeamRadius,
segmentLength/2., rotCPS2);
- TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(*transCPS2);
+
+ TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
+ -fgkLadderHeight/2.- tDY
+ +coolPipeSuppH+fgkLadderBeamRadius,
+ segmentLength/2., rotCPS2);
AddTranslationToCombiTrans(transCPS4, 0, 0, -segmentLength);
virtualSeg->AddNode(fCoolPipeSupportL, 1, transCPS1);
Double_t shiftHyb = 1.05; // shift between thermal Bridge base and thermal bridge
// approx !!! not clear on 0752/14-A
if (fAddCoolingSyst) {
- TGeoRotation *rotHybrid1 = new TGeoRotation("", 0, 0, -90 - fgkHybridAngle);
- TGeoRotation *rotHybrid2 = new TGeoRotation("", 0 ,180, 90 - fgkHybridAngle);
- TGeoCombiTrans *baseTr1 = new TGeoCombiTrans(*pipeTr2, *rotHybrid1);
- TGeoCombiTrans *baseTr2 = new TGeoCombiTrans(*pipeTr1, *rotHybrid2);
+ TGeoRotation rotHybrid1("", 0, 0, -90 - fgkHybridAngle);
+ TGeoRotation rotHybrid2("", 0 ,180, 90 - fgkHybridAngle);
+ TGeoCombiTrans *baseTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid1);
+ TGeoCombiTrans *baseTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid2);
virtualSeg->AddNode(fBaseThermalBridge, 1, baseTr1);
virtualSeg->AddNode(fBaseThermalBridge, 2, baseTr2);
//________________________________________________________________________
TGeoVolume* AliITSv11GeometrySDD::CreatePinSupport() {
//
-// Create a pine support
+// Create a pine support and its pine
// axis of rotation is the cone axis, center in its middle
//
+ TGeoMedium *rytonSDD = GetMedium("SDD C AL (M55J)$"); //medium = ryton ?
+
TGeoCone *cone = new TGeoCone("ITSsddPinSuppCone",fgkPinSuppHeight/2.,
0,fgkPinSuppRmax,0,fgkPinSuppRmax-
fgkPinSuppHeight*TanD(fgkPinSuppConeAngle) );
TGeoBBox *tong = new TGeoBBox("ITSsddPinSuppTong",fgkPinSuppRmax,
fgkPinSuppLength/2.,fgkPinSuppThickness/2.);
TGeoTube *hole = new TGeoTube("ITSsddPinSuppHole",0,fgkPinR,
- fgkPinSuppHeight/2.);
+ fgkPinSuppHeight/2.+0.00001);
+ // 0.00001 is for seing the actual hole (avoid viewer artefact)
+
if(GetDebug(3)){// Remove compiler warning.
cone->InspectShape();
tong->InspectShape();
tongTrans->RegisterYourself();
TGeoCompositeShape *pinSupportShape = new TGeoCompositeShape(
"ITSsddPinSupportShape","(ITSsddPinSuppCone+"
- "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole");
+ "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole");
-
- TGeoMedium *rytonSDD = GetMedium("SDD C AL (M55J)$"); //medium = ryton ? To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- TGeoVolume *pinSupport = new TGeoVolume("ITSsddPinSupport",pinSupportShape,
+ TGeoVolume *pinSupport = new TGeoVolume("ITSsddPinSupport", pinSupportShape,
rytonSDD);
pinSupport->SetLineColor(fColorRyton);
+
return pinSupport;
- // include the pin itself !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
// Return an assembly containing a end of a CF ladder.
//
- // Ces mesures sont pour l'instant temporaires ! drawings ???!!!!!!!!
- Double_t fgkCoolPipeLay3Len = 467*fgkmm;
- Double_t fgkCoolPipeLay4Len = 616.*fgkmm;
-
- Double_t fgkHVguideX1 = 42.5*fgkmm;
- Double_t fgkHVguideY1 = 7.*fgkmm;
- Double_t fgkHVguideZ1 = 10.*fgkmm;
- Double_t fgkHVguideZ2 = 6.*fgkmm;
- Double_t fgkHVguideDX = -8.5*fgkmm;
-
- Double_t fgkHVguideSuppFullZ = 37.5*fgkmm;
-
-
-
-
-
TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); // ITSsddCarbonM55J
- TGeoMedium *stesalite = GetMedium("EPOXY$"); /// To code ??? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- TGeoMedium *phynoxSDD = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *stesalite = GetMedium("G10FR4$");
+ TGeoMedium *phynoxSDD = GetMedium("INOX$");
TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
Double_t length = (fgkLay3LadderLength-fgkLay3Ndet*fgkSegmentLength)/2.;
//**********************************
//--- The stesalite foot of the ladder
+ Double_t footDY = -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY
+ - fgkLadFootY/2+fgkLadFingerPrintY;
+
+ TGeoTranslation *footTr = new TGeoTranslation("SDDfootTr",0,footDY,footDZ);
+ virtualEnd->AddNode(fLadderFoot, 1, footTr);
+
+ //=====================================
+ //--- cooling pipe
+
+ if (fAddCoolingSyst) {
+
+ TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
+ -fgkLadderHeight/2.+ tDY +
+ coolPipeSuppH + fgkLadderBeamRadius,
+ -length/2.+coolPipeEndLen/2.);
+ TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
+ -fgkLadderHeight/2. + tDY +
+ fgkLadderBeamRadius + coolPipeSuppH,
+ -length/2.+coolPipeEndLen/2.);
+
+ TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
+ fgkCoolPipeOuterDiam/2,
+ coolPipeEndLen/2);
+ TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
+ coolPipeEndLen/2);
+
+ TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipeEnd",
+ coolingPipeShape, phynoxSDD );
+ coolingPipe->SetLineColor(fColorPhynox);
+ TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingEndLiquid",coolerShape,
+ coolerMediumSDD );
+
+ virtualEnd->AddNode(coolingPipe, 1, pipeTr1);
+ virtualEnd->AddNode(coolingPipe, 2, pipeTr2);
+ if (fCoolingOn) {
+ virtualEnd->AddNode(cooler, 1, pipeTr1);
+ virtualEnd->AddNode(cooler, 2, pipeTr2);
+ };
+ };
+
+ //=====================================
+ //--- HV cable guide
+
+
+ TGeoBBox* guideHVbox = new TGeoBBox("guideHVbox",fgkHVguideX1/2,
+ fgkHVguideY1/2,fgkHVguideZ1/2);
+ TGeoVolume *guideHV = new TGeoVolume("guideHV",guideHVbox,stesalite);
+
+ TGeoTranslation* guideHVtr = new TGeoTranslation(fgkHVguideDX,
+ -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY-fgkHVguideY1/2,
+ footDZ+fgkLadFootZ/2+fgkHVguideZ1/2-(fgkHVguideSuppFullZ-fgkHVguideZ2));
+ virtualEnd->AddNode(guideHV, 1, guideHVtr);
+
+ //=====================================
+ //--- raccordo
+ Double_t raccordFullLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
+ TGeoTranslation *trRaccordo1 = new TGeoTranslation("trRaccordo1",-coolPipeSuppL,
+ -fgkLadderHeight/2.+ tDY +
+ coolPipeSuppH+fgkLadderBeamRadius,
+ -length/2.+coolPipeEndLen+raccordFullLen/2);
+ TGeoTranslation *trRaccordo2 = new TGeoTranslation("trRaccordo2", coolPipeSuppL,
+ -fgkLadderHeight/2.+ tDY +
+ coolPipeSuppH+fgkLadderBeamRadius,
+ -length/2.+coolPipeEndLen+raccordFullLen/2);
+
+ virtualEnd->AddNode(fRaccordoL, 1, trRaccordo1);
+ virtualEnd->AddNode(fRaccordoL, 2, trRaccordo2);
+
+ if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
+
+ return virtualEnd;
+}
+
+//________________________________________________________________________
+TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateLadderFoot() {
+
+ //--- The stesalite foot of the ladder
// Are missing :
// The 2 screw holes on the left part
// the small holes at each corner of the ruby cage (diam 2mm)
// the really small level difference of 0.3mm on the bottom
- Double_t footDY = -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY
- - fgkLadFoot_Y/2+fgkLadFingerPrint_Y;
+
+ TGeoMedium *stesalite = GetMedium("G10FR4$");
+
+ TGeoVolumeAssembly *virtualFoot = new TGeoVolumeAssembly("ITSsddFoot");
Double_t epsilon = 2e-10;
- TGeoBBox *ladFootBox1 = new TGeoBBox("ladFootBox1",fgkLadBox1_X/2, fgkLadFoot_Y/2,
- fgkLadFoot_Z/2);
+ TGeoBBox *ladFootBox1 = new TGeoBBox("ladFootBox1",fgkLadBox1X/2, fgkLadFootY/2,
+ fgkLadFootZ/2);
TGeoTranslation *ladFootBox1Tr = new TGeoTranslation("ladFootBox1Tr",
- fgkLadFoot_X/2-fgkLadBox1_X/2,0,0);
- TGeoBBox *ladFingerPrint = new TGeoBBox("ladFingerPrint",fgkLadFingerPrint_X/2,
- fgkLadFingerPrint_Y/2+epsilon, fgkLadFoot_Z/2+epsilon);
+ fgkLadFootX/2-fgkLadBox1X/2,0,0);
+ TGeoBBox *ladFingerPrint = new TGeoBBox("ladFingerPrint",fgkLadFingerPrintX/2,
+ fgkLadFingerPrintY/2+epsilon, fgkLadFootZ/2+epsilon);
TGeoTranslation *ladFingerPrintTr = new TGeoTranslation("ladFingerPrintTr",
- fgkLadFoot_X/2-fgkLadFingerPrintBorder-fgkLadFingerPrint_X/2,
- fgkLadFoot_Y/2-fgkLadFingerPrint_Y/2+epsilon,
+ fgkLadFootX/2-fgkLadFingerPrintBorder-fgkLadFingerPrintX/2,
+ fgkLadFootY/2-fgkLadFingerPrintY/2+epsilon,
0);
TGeoBBox *rubyCageHole = new TGeoBBox("rubyCageHole",fgkRubyCageHoleX/2,
fgkRubyCageHoleY/2+epsilon, fgkRubyCageHoleZ/2);
TGeoTranslation *rubyCageHoleTr = new TGeoTranslation("rubyCageHoleTr",
- fgkLadFoot_X/2-(fgkLadFoot_X/2-fgkRubyDX)+fgkRubyCageAxisShift,
- fgkLadFoot_Y/2-fgkRubyCageHoleY/2,0);
+ fgkLadFootX/2-(fgkLadFootX/2-fgkRubyDX)+fgkRubyCageAxisShift,
+ fgkLadFootY/2-fgkRubyCageHoleY/2,0);
- double rubyScrewHoleLen = fgkLadFoot_X/2-fgkRubyDX;
+ double rubyScrewHoleLen = fgkLadFootX/2-fgkRubyDX;
TGeoTube *rubyScrewHole = new TGeoTube("rubyScrewHole", 0,fgkScrewM4diam/2,
rubyScrewHoleLen/2);
TGeoRotation *rot9090 = new TGeoRotation("",90,90,0);
TGeoCombiTrans *rubyScrewHoleTr = new TGeoCombiTrans("rubyScrewHoleTr",
- fgkLadFoot_X/2-rubyScrewHoleLen/2,
+ fgkLadFootX/2-rubyScrewHoleLen/2,
-fgkRubyScrewShiftToCenterY, 0, rot9090);
- Double_t rubyHoleLen = fgkLadFoot_Y-fgkRubyCageHoleY;
+ Double_t rubyHoleLen = fgkLadFootY-fgkRubyCageHoleY;
TGeoTube *rubyHole = new TGeoTube("rubyHole", 0,fgkRubyHoleDiam/2,
rubyHoleLen/2);
TGeoRotation *rot90 = new TGeoRotation("",0,90,0);
TGeoCombiTrans *rubyHoleTr = new TGeoCombiTrans("rubyHoleTr", fgkRubyDX,
- -(fgkLadFoot_Y-rubyHoleLen)/2, 0, rot90);
+ -(fgkLadFootY-rubyHoleLen)/2, 0, rot90);
ladFootBox1Tr->RegisterYourself();
ladFingerPrintTr->RegisterYourself();
footRightPart,stesalite);
vFootRightPart->SetLineColor(fColorStesalite);
- TGeoTranslation *vFootRightPartTr = new TGeoTranslation("vFootRightPartTr",
- 0, footDY, footDZ);
- virtualEnd->AddNode(vFootRightPart, 1, vFootRightPartTr);
+ virtualFoot->AddNode(vFootRightPart, 1, 0);
//--- This was the right part of the foot, now let's do the middle
//--- and the right parts
- Double_t middleX = fgkLadFoot_X-fgkLadBox1_X-fgkLadFingerPrint_X-fgkLadFingerPrintBorder;
+ Double_t middleX = fgkLadFootX-fgkLadBox1X-fgkLadFingerPrintX-fgkLadFingerPrintBorder;
TGeoBBox *footMiddle = new TGeoBBox("footMiddle", middleX/2, fgkLadFootMiddleY/2,
- fgkLadFoot_Z/2);
+ fgkLadFootZ/2);
TGeoTranslation *middleXTr = new TGeoTranslation("middleXTr",
- fgkLadFoot_X/2-fgkLadBox1_X-middleX/2,
- fgkLadFoot_Y/2-fgkLadFootMiddleY/2 + footDY, footDZ);
+ fgkLadFootX/2-fgkLadBox1X-middleX/2,
+ fgkLadFootY/2-fgkLadFootMiddleY/2, 0);
TGeoVolume *vFootMiddle = new TGeoVolume("vFootMiddle", footMiddle,stesalite);
vFootMiddle->SetLineColor(fColorStesalite);
- virtualEnd->AddNode(vFootMiddle, 1, middleXTr);
+ virtualFoot->AddNode(vFootMiddle, 1, middleXTr);
//--
- TGeoBBox *footLeftLadFinger = new TGeoBBox("footLeftLadFinger", fgkLadFingerPrint_X/2,
- (fgkLadFoot_Y-fgkLadFingerPrint_Y)/2,
- fgkLadFoot_Z/2);
+ TGeoBBox *footLeftLadFinger = new TGeoBBox("footLeftLadFinger", fgkLadFingerPrintX/2,
+ (fgkLadFootY-fgkLadFingerPrintY)/2,
+ fgkLadFootZ/2);
TGeoTranslation *footLeftLadFingerTr = new TGeoTranslation("footLeftLadFingerTr",
- -fgkLadFoot_X/2+fgkLadFingerPrintBorder+fgkLadFingerPrint_X/2,
- -fgkLadFingerPrint_Y/2 + footDY, footDZ);
+ -fgkLadFootX/2+fgkLadFingerPrintBorder+fgkLadFingerPrintX/2,
+ -fgkLadFingerPrintY/2, 0);
TGeoVolume *vFootLeftLadFinger = new TGeoVolume("vFootLeftLadFinger",footLeftLadFinger,
stesalite);
vFootLeftLadFinger->SetLineColor(fColorStesalite);
- virtualEnd->AddNode(vFootLeftLadFinger, 1, footLeftLadFingerTr);
+ virtualFoot->AddNode(vFootLeftLadFinger, 1, footLeftLadFingerTr);
//--
TGeoBBox *footLeft = new TGeoBBox("footLeft", fgkLadFingerPrintBorder/2,
- fgkLadFoot_Y/2,
- fgkLadFoot_Z/2);
+ fgkLadFootY/2,
+ fgkLadFootZ/2);
TGeoTranslation *footLeftTr = new TGeoTranslation("footLeftTr",
- -fgkLadFoot_X/2+fgkLadFingerPrintBorder/2,
- footDY, footDZ);
+ -fgkLadFootX/2+fgkLadFingerPrintBorder/2,
+ 0, 0);
TGeoVolume *vFootLeft = new TGeoVolume("vFootLeft",footLeft,stesalite);
vFootLeft->SetLineColor(fColorStesalite);
- virtualEnd->AddNode(vFootLeft, 1, footLeftTr);
-
- //=====================================
- //--- cooling pipe
-
- if (fAddCoolingSyst) {
-
- TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
- -fgkLadderHeight/2.+ tDY +
- coolPipeSuppH + fgkLadderBeamRadius,
- -length/2.+coolPipeEndLen/2.);
- TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
- -fgkLadderHeight/2. + tDY +
- fgkLadderBeamRadius + coolPipeSuppH,
- -length/2.+coolPipeEndLen/2.);
-
- TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
- fgkCoolPipeOuterDiam/2,
- coolPipeEndLen/2);
- TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
- coolPipeEndLen/2);
-
- TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipeEnd",
- coolingPipeShape, phynoxSDD );
- coolingPipe->SetLineColor(fColorPhynox);
- TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingEndLiquid",coolerShape,
- coolerMediumSDD );
-
- virtualEnd->AddNode(coolingPipe, 1, pipeTr1);
- virtualEnd->AddNode(coolingPipe, 2, pipeTr2);
- if (fCoolingOn) {
- virtualEnd->AddNode(cooler, 1, pipeTr1);
- virtualEnd->AddNode(cooler, 2, pipeTr2);
- };
- };
-
- //=====================================
- //--- HV cable guide
-
+ virtualFoot->AddNode(vFootLeft, 1, footLeftTr);
- TGeoBBox* guideHVbox = new TGeoBBox("guideHVbox",fgkHVguideX1/2,
- fgkHVguideY1/2,fgkHVguideZ1/2);
- TGeoVolume *guideHV = new TGeoVolume("guideHV",guideHVbox,stesalite); // material ?
-
- TGeoTranslation* guideHVtr = new TGeoTranslation(fgkHVguideDX,
- -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY-fgkHVguideY1/2,
- footDZ+fgkLadFoot_Z/2+fgkHVguideZ1/2-(fgkHVguideSuppFullZ-fgkHVguideZ2));
- virtualEnd->AddNode(guideHV, 1, guideHVtr);
-
-
- if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
if(GetDebug(3)){ // Remove compiler warning.
ladFingerPrint->InspectShape();
ladFootBox1->InspectShape();
rubyHole->InspectShape();
}
- return virtualEnd;
+ return virtualFoot;
}
//________________________________________________________________________
TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateCarlosCard(Int_t iLay) {
-//
-// To e done
-//
+ //
+ // return an assembly containing the CARLOS end-ladder board
+ // and the heat bridge
+ //
- iLay=iLay;
- return 0;
-}
+ (void) iLay;
+ TGeoMedium *glassFiber = GetMedium("SDD SI CHIP$");// glassFiber TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip
+ TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
+ TGeoMedium *copper = GetMedium("COPPER$");
+ TGeoMedium *alCu12SDD = GetMedium("INOX$"); // ITSsddAlCu12, to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *stainless = GetMedium("INOX$"); // for screws, what is the material ???????????
+
+ //=========================================
+ // cooling support of the Carlos card (HeatBridge):
+ TGeoVolumeAssembly *assemblySupCarlos = new TGeoVolumeAssembly("assemblySupCarlos");
+
+ TGeoBBox *supCarlosBoard1 = new TGeoBBox("",fgkCarlosSuppX1/2,fgkCarlosSuppY1/2,
+ fgkCarlosSuppZ/2);
+ TGeoBBox *supCarlosBoard2 = new TGeoBBox("",fgkCarlosSuppX2/2,fgkCarlosSuppY2/2,
+ fgkCarlosSuppZ/2);
+ TGeoVolume *vSupCarlosBoard1 = new TGeoVolume("vSupCarlosBoard1",
+ supCarlosBoard1, alCu12SDD);
+ TGeoVolume *vSupCarlosBoard2 = new TGeoVolume("vSupCarlosBoard2",
+ supCarlosBoard2, alCu12SDD);
+ vSupCarlosBoard1->SetLineColor(4);
+ vSupCarlosBoard2->SetLineColor(4);
+
+
+ Double_t shiftGlob = -fgkCarlosSuppZ/2+fgkCarlosSuppTopLen;
+ // shift of the main planes in the direction of their width
+ // the center is fixed at the center of the 2 small fixing arms on each sides.
+ //shiftGlob=0.5;
+
+ shiftGlob+= 0.5*fgkCarlosSuppY3/cos((90-fgkCarlosSuppAngle)*TMath::DegToRad());
+ shiftGlob-= 0.5*fgkCarlosSuppY2*tan((90-fgkCarlosSuppAngle)*TMath::DegToRad());
+ Double_t shiftGlobY = shiftGlob*sin(fgkCarlosSuppAngle*TMath::DegToRad());
+ Double_t shiftGlobZ = shiftGlob*cos(fgkCarlosSuppAngle*TMath::DegToRad());
+
+ TGeoTranslation *carlosSupTr1 = new TGeoTranslation( -fgkCarlosSuppX2/2,
+ (-fgkCarlosSuppY1+fgkCarlosSuppY2)/2+shiftGlobY,
+ +shiftGlobZ);
+
+ TGeoTranslation *carlosSupTr2 = new TGeoTranslation( fgkCarlosSuppX1/2,
+ shiftGlobY,
+ shiftGlobZ);
+
+ assemblySupCarlos->AddNode(vSupCarlosBoard1, 0, carlosSupTr1);
+ assemblySupCarlos->AddNode(vSupCarlosBoard2, 0, carlosSupTr2);
+
+ //=========================================
+ // fixing arm of the cooling support :
+ TGeoBBox *supCarlosBoard3 = new TGeoBBox("",fgkCarlosSuppX3/2,fgkCarlosSuppY3/2,
+ fgkCarlosSuppZ3/2);
+ TGeoVolume *vSupCarlosBoard3 = new TGeoVolume("vSupCarlosBoard3",
+ supCarlosBoard3, alCu12SDD);
+ vSupCarlosBoard3->SetLineColor(4);
+
+ // screw inside :
+ TGeoTube *littleScrew = new TGeoTube("littleScrew", 0, fgkLittleScrewR,
+ fgkCarlosSuppY3/2);
+ TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrew",
+ littleScrew, stainless);
+ TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
+ TGeoCombiTrans *cbScrew1 = new TGeoCombiTrans(0, 0, fgkCarlosSuppZ3/2 -
+ fgkLittleScrewHeadR-0.07, rotScrew);
+ TGeoCombiTrans *cbScrew2 = new TGeoCombiTrans(0, 0, -fgkCarlosSuppZ3/2 +
+ fgkLittleScrewHeadR+0.07, rotScrew);
+ vSupCarlosBoard3->AddNode(vLittleScrew,1, cbScrew1);
+ vSupCarlosBoard3->AddNode(vLittleScrew,2, cbScrew2);
+
+ TGeoRotation *carlosSupRot = new TGeoRotation("carlosSuppInvertAngle",
+ 0, fgkCarlosSuppAngle, 0);
+ TGeoCombiTrans *carlosSupTr3 = new TGeoCombiTrans((fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
+ TGeoCombiTrans *carlosSupTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
+ assemblySupCarlos->AddNode(vSupCarlosBoard3, 0, carlosSupTr3);
+ assemblySupCarlos->AddNode(vSupCarlosBoard3, 1, carlosSupTr4);
+
+
+ //=========================================
+ // screws fixing the board on the U tube
+ Double_t aaa = fgkCarlosSuppY3; // ???
+ //Double_t aaa = fgkCarlosSuppY3/2 + fgkLittleScrewHeadH/2;
+ Double_t bbb = fgkCarlosSuppZ3/2 - fgkLittleScrewHeadR;
+ Double_t screw1y = ( aaa*cos(TMath::DegToRad()*fgkCarlosSuppAngle) -
+ bbb*sin(TMath::DegToRad()*fgkCarlosSuppAngle) );
+ Double_t screw1z = ( aaa*sin(TMath::DegToRad()*fgkCarlosSuppAngle) +
+ bbb*cos(TMath::DegToRad()*fgkCarlosSuppAngle) )-0.07;
+
+ TGeoRotation *CarlosSuppRot = (TGeoRotation *)fCommonTr[0];
+
+ TGeoCombiTrans* lScrewTr1 = new TGeoCombiTrans((fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
+ screw1y,screw1z, CarlosSuppRot);
+
+ TGeoCombiTrans* lScrewTr2 = new TGeoCombiTrans((fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
+ screw1z,screw1y, CarlosSuppRot);
+
+ TGeoCombiTrans *lScrewTr3 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
+ screw1y,screw1z, CarlosSuppRot);
+
+ TGeoCombiTrans *lScrewTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
+ fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
+ screw1z,screw1y, CarlosSuppRot);
+
+ assemblySupCarlos->AddNode(fCommonVol[0], 1, lScrewTr1);
+ assemblySupCarlos->AddNode(fCommonVol[0], 2, lScrewTr2);
+ assemblySupCarlos->AddNode(fCommonVol[0], 3, lScrewTr3);
+ assemblySupCarlos->AddNode(fCommonVol[0], 4, lScrewTr4);
+ //=========================================
+ // board
+ Double_t p1[3], p2[3], vX[3] = {1,0,0};
+ AliITSv11GeomCableFlat card1("cardCarlos1", fgkCarlosCardZ1, fgkCarlosCardY1); // name, width, thickness
+ card1.SetNLayers(2);
+ card1.SetLayer(0, fgkCarlosCardCuY, copper, kOrange); // index, thickness, material, color
+ card1.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY, glassFiber, 30);
+ card1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+ p1[0] = -fgkCarlosCardX1/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
+ p1[2] = fgkCarlosCardShift;
+ p2[0] = fgkCarlosCardX1/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
+ p2[2] = fgkCarlosCardShift;
+ card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ card1.CreateAndInsertBoxCableSegment(1,90);
+
+ AliITSv11GeomCableFlat card2("cardCarlos2", fgkCarlosCardZ2, fgkCarlosCardY1); // name, width, thickness
+ card2.SetNLayers(2);
+ card2.SetLayer(0, fgkCarlosCardCuY, copper, kOrange); // index, thickness, material, color
+ card2.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY, glassFiber, 30);
+ card2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = -fgkCarlosCardX1/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
+ p1[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
+
+ p2[0] = -fgkCarlosCardX1/2 + fgkCarlosCardX2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
+ p2[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
+ card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ card2.CreateAndInsertBoxCableSegment(1,90);
+
+ //=========================================
+ // some chips on the board
+
+ AliITSv11GeomCableFlat u1("carlosCardU1", fgkCarlosU1Z, fgkCarlosU1Y); // name, width, thickness
+ u1.SetNLayers(2);
+ u1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u1.SetLayer(1, fgkCarlosU1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosU1posX - fgkCarlosU1X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
+
+ p2[0] = fgkCarlosU1posX + fgkCarlosU1X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
+ u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ u1.CreateAndInsertBoxCableSegment(1,90);
+
+ //---
+ AliITSv11GeomCableFlat u2("carlosCardU2", fgkCarlosU2Z, fgkCarlosU2Y); // name, width, thickness
+ u2.SetNLayers(2);
+ u2.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u2.SetLayer(1, fgkCarlosU2Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosU2posX - fgkCarlosU2X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
+
+ p2[0] = fgkCarlosU2posX + fgkCarlosU2X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
+ u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ u2.CreateAndInsertBoxCableSegment(1,90);
+
+ //---
+ AliITSv11GeomCableFlat u3("carlosCardU3", fgkCarlosU3Z, fgkCarlosU3Y); // name, width, thickness
+ u3.SetNLayers(2);
+ u3.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u3.SetLayer(1, fgkCarlosU3Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u3.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ Double_t u3Y = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU3Y/2;
+ p1[0] = fgkCarlosU3posX - fgkCarlosU3X/2;
+ p1[1] = u3Y;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
+
+ p2[0] = fgkCarlosU3posX + fgkCarlosU3X/2;
+ p2[1] = u3Y;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
+ u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ TGeoVolume *u3Vol = u3.CreateAndInsertBoxCableSegment(1,90);
+
+ //--- U4 is like U3 (?)
+ TGeoCombiTrans *u4Trans = new TGeoCombiTrans;
+ u4Trans->RotateX(90);
+ u4Trans->SetTranslation(fgkCarlosU4posX, u3Y,
+ fgkCarlosCardShift + fgkCarlosU4posZ);
+ assemblySupCarlos->AddNode(u3Vol, 2, u4Trans);
+
+ //---
+ AliITSv11GeomCableFlat u17("carlosCardU17", fgkCarlosU17Z, fgkCarlosU17Y); // name, width, thickness
+ u17.SetNLayers(2);
+ u17.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u17.SetLayer(1, fgkCarlosU17Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u17.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosU17posX - fgkCarlosU17X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
+
+ p2[0] = fgkCarlosU17posX + fgkCarlosU17X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
+ u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ u17.CreateAndInsertBoxCableSegment(1,90);
+
+ //---
+ AliITSv11GeomCableFlat u35("carlosCardU35", fgkCarlosU35Z, fgkCarlosU35Y); // name, width, thickness
+ u35.SetNLayers(2);
+ u35.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u35.SetLayer(1, fgkCarlosU35Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u35.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosU35posX - fgkCarlosU35X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
+
+ p2[0] = fgkCarlosU35posX + fgkCarlosU35X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
+ u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ u35.CreateAndInsertBoxCableSegment(1,90);
+
+ //---
+ AliITSv11GeomCableFlat u36("carlosCardU36", fgkCarlosU36Z, fgkCarlosU36Y); // name, width, thickness
+ u36.SetNLayers(2);
+ u36.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ u36.SetLayer(1, fgkCarlosU36Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ u36.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosU36posX - fgkCarlosU36X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
+
+ p2[0] = fgkCarlosU36posX + fgkCarlosU36X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
+ u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ u36.CreateAndInsertBoxCableSegment(1,90);
+
+ //--- QZ1
+ AliITSv11GeomCableFlat qz1("carlosCardQZ1", fgkCarlosQZ1Z, fgkCarlosQZ1Y); // name, width, thickness
+ qz1.SetNLayers(2);
+ qz1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
+ qz1.SetLayer(1, fgkCarlosQZ1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
+ qz1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
+
+ p1[0] = fgkCarlosQZ1posX - fgkCarlosQZ1X/2;
+ p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
+ p1[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
+
+ p2[0] = fgkCarlosQZ1posX + fgkCarlosQZ1X/2;
+ p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
+ p2[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
+ qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
+ qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
+ qz1.CreateAndInsertBoxCableSegment(1,90);
+
+ return assemblySupCarlos;
+}
//________________________________________________________________________
-TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateLVCard(Int_t orientation) {
+Int_t AliITSv11GeometrySDD::CreateLVCard() {
//
- // return an assembly containing the carlos card
+ // Creates the assemblies containing the LV cards (left and right)
//
TGeoMedium *glassFiber = GetMedium("SDD SI CHIP$");// glassFiber TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
TGeoMedium *copper = GetMedium("COPPER$");
TGeoMedium *alCu12SDD = GetMedium("INOX$"); // ITSsddAlCu12, to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *stainless = GetMedium("INOX$"); // for screws, what is the material ???????????
- char *ch;
- if (orientation==1) ch="ITSsddLVCardLeft";
- else ch="ITSsddLVCardRight";
- TGeoVolumeAssembly *cardLVassembly = new TGeoVolumeAssembly(ch);
+ fCardLVL = new TGeoVolumeAssembly("ITSsddLVCardLeft");
+ fCardLVR = new TGeoVolumeAssembly("ITSsddLVCardRight");
- // we are going to use flat cable class to create multilayer box ...
+ // we are going to use flat cable class to create multilayer box,
+ // then we can use the pointers to created volumes to place them elsewhere
Double_t p1[3], p2[3], vX[3] = {1,0,0};
- Double_t carLVfullThick = fgkLVcard_Z+fgkLVcard_CuZ;
- AliITSv11GeomCableFlat cardLV("cardLV", fgkLVcard_Y, carLVfullThick); // name, width, thickness
+ Double_t carLVfullThick = fgkLVcardZ+fgkLVcardCuZ;
+ AliITSv11GeomCableFlat cardLV("cardLV", fgkLVcardY, carLVfullThick); // name, width, thickness
cardLV.SetNLayers(2);
- cardLV.SetLayer(0, fgkLVcard_CuZ, copper, 30); // index, thickness, material, color
- cardLV.SetLayer(1, fgkLVcard_Z, glassFiber, 30);
- cardLV.SetInitialNode( (TGeoVolume *) cardLVassembly);
+ cardLV.SetLayer(0, fgkLVcardCuZ, copper, 30); // index, thickness, material, color
+ cardLV.SetLayer(1, fgkLVcardZ, glassFiber, 30);
+ cardLV.SetInitialNode( (TGeoVolume *) fCardLVL);
p1[0] = 0;
- p1[1] = fgkLVcard_Y/2;
+ p1[1] = fgkLVcardY/2;
p1[2] = 0;
- p2[0] = orientation*fgkLVcard_X;
- p2[1] = fgkLVcard_Y/2;
+ p2[0] = fgkLVcardX;
+ p2[1] = fgkLVcardY/2;
p2[2] = 0;
- cardLV.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- cardLV.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- cardLV.CreateAndInsertBoxCableSegment(1);
-
- Double_t chip0fullThick = fgkLVChip0_Z + fgkLVChip0_SiZ;
- AliITSv11GeomCableFlat chipO("chipO", fgkLVChip0_Y, chip0fullThick); // name, width, thickness
+ cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
+ cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
+ TGeoVolume* boxVol = cardLV.CreateAndInsertBoxCableSegment(1);
+ TGeoRotation *rotAdd = new TGeoRotation("",90,0,0);
+ TGeoCombiTrans *trCard = new TGeoCombiTrans(-fgkLVcardX/2,fgkLVcardY/2,0,rotAdd);
+ fCardLVR->AddNode(boxVol, 1, trCard);
+
+ Double_t chip0fullThick = fgkLVChip0Z + fgkLVChip0SiZ;
+ AliITSv11GeomCableFlat chipO("chipO", fgkLVChip0Y, chip0fullThick); // name, width, thickness
chipO.SetNLayers(2);
- chipO.SetLayer(0, fgkLVChip0_SiZ, siliconChip, 8); // index, thickness, material, color
- chipO.SetLayer(1, fgkLVChip0_Z, plastiChip, 12);
- chipO.SetInitialNode( (TGeoVolume *) cardLVassembly);
- p1[0] = orientation*(fgkLVChip0_PosX - fgkLVChip0_X/2);
- p1[1] = fgkLVChip0_PosY;
+ chipO.SetLayer(0, fgkLVChip0SiZ, siliconChip, 8); // index, thickness, material, color
+ chipO.SetLayer(1, fgkLVChip0Z, plastiChip, 12);
+ chipO.SetInitialNode( (TGeoVolume *) fCardLVL);
+ p1[0] = (fgkLVChip0PosX - fgkLVChip0X/2);
+ p1[1] = fgkLVChip0PosY;
p1[2] = carLVfullThick/2 + chip0fullThick/2;
- p2[0] = orientation*(fgkLVChip0_PosX + fgkLVChip0_X/2);
- p2[1] = fgkLVChip0_PosY;
+
+ p2[0] = (fgkLVChip0PosX + fgkLVChip0X/2);
+ p2[1] = fgkLVChip0PosY;
p2[2] = carLVfullThick/2 + chip0fullThick/2;
- chipO.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- chipO.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- chipO.CreateAndInsertBoxCableSegment(1);
-
- //same chip but the other side
- AliITSv11GeomCableFlat chipOB("chipOB", fgkLVChip0_Y, chip0fullThick); // name, width, thickness
- chipOB.SetNLayers(2);
- chipOB.SetLayer(0, fgkLVChip0_SiZ, siliconChip, 8); // index, thickness, material, color
- chipOB.SetLayer(1, fgkLVChip0_Z, plastiChip, 12);
- chipOB.SetInitialNode( (TGeoVolume *) cardLVassembly);
-
- p1[2] = -carLVfullThick/2 - chip0fullThick/2;
- p2[2] = -carLVfullThick/2 - chip0fullThick/2;
- chipOB.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- chipOB.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- chipOB.CreateAndInsertBoxCableSegment(1);
-
-
- Double_t chip1fullThick = fgkLVChip1_Z + fgkLVChip1_SiZ;
- AliITSv11GeomCableFlat chip1("chip1", fgkLVChip1_Y, chip1fullThick);
+ chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
+ chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
+ boxVol = chipO.CreateAndInsertBoxCableSegment(1);
+ trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
+ fgkLVChip0PosY,
+ carLVfullThick/2+chip0fullThick/2, rotAdd);
+ fCardLVR->AddNode(boxVol, 1, trCard);
+
+ // put also this chip on the other side of the card
+ trCard = new TGeoCombiTrans( fgkLVChip0PosX,
+ fgkLVChip0PosY,
+ -carLVfullThick/2-chip0fullThick/2, rotAdd);
+ fCardLVL->AddNode(boxVol, 2, trCard);
+ trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
+ fgkLVChip0PosY,
+ -carLVfullThick/2-chip0fullThick/2, rotAdd);
+ fCardLVR->AddNode(boxVol, 2, trCard);
+
+ Double_t chip1fullThick = fgkLVChip1Z + fgkLVChip1SiZ;
+ AliITSv11GeomCableFlat chip1("chip1", fgkLVChip1Y, chip1fullThick);
chip1.SetNLayers(2);
- chip1.SetLayer(0, fgkLVChip1_SiZ, siliconChip, 8);
- chip1.SetLayer(1, fgkLVChip1_Z, plastiChip, 12);
- chip1.SetInitialNode( (TGeoVolume *) cardLVassembly);
- p1[0] = orientation*(fgkLVChip1_PosX-fgkLVChip1_X/2);
- p1[1] = fgkLVChip1_PosY;
+ chip1.SetLayer(0, fgkLVChip1SiZ, siliconChip, 8);
+ chip1.SetLayer(1, fgkLVChip1Z, plastiChip, 12);
+ chip1.SetInitialNode( (TGeoVolume *) fCardLVL);
+ p1[0] = (fgkLVChip1PosX-fgkLVChip1X/2);
+ p1[1] = fgkLVChip1PosY;
p1[2] = carLVfullThick/2 + chip1fullThick/2;
- p2[0] = orientation*(fgkLVChip1_PosX+fgkLVChip1_X/2);
- p2[1] = fgkLVChip1_PosY;
+ p2[0] = (fgkLVChip1PosX+fgkLVChip1X/2);
+ p2[1] = fgkLVChip1PosY;
p2[2] = carLVfullThick/2 + chip1fullThick/2;
- chip1.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- chip1.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- chip1.CreateAndInsertBoxCableSegment(1);
-
- Double_t chip2fullThick = fgkLVChip2_Z + fgkLVChip2_SiZ;
- AliITSv11GeomCableFlat chip2("chip2", fgkLVChip2_Y, chip2fullThick);
+ chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
+ chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
+ boxVol = chip1.CreateAndInsertBoxCableSegment(1);
+ trCard = new TGeoCombiTrans( -fgkLVChip1PosX,
+ fgkLVChip1PosY,
+ carLVfullThick/2 + chip1fullThick/2, rotAdd);
+ fCardLVR->AddNode(boxVol, 1, trCard);
+
+ Double_t chip2fullThick = fgkLVChip2Z + fgkLVChip2SiZ;
+ AliITSv11GeomCableFlat chip2("chip2", fgkLVChip2Y, chip2fullThick);
chip2.SetNLayers(2);
- chip2.SetLayer(0, fgkLVChip2_SiZ, siliconChip, 8);
- chip2.SetLayer(1, fgkLVChip2_Z, plastiChip, 12);
- chip2.SetInitialNode( (TGeoVolume *) cardLVassembly);
- p1[0] = orientation*(fgkLVChip2_PosX-fgkLVChip2_X/2);
- p1[1] = fgkLVChip2_PosY;
+ chip2.SetLayer(0, fgkLVChip2SiZ, siliconChip, 8);
+ chip2.SetLayer(1, fgkLVChip2Z, plastiChip, 12);
+ chip2.SetInitialNode( (TGeoVolume *) fCardLVL);
+ p1[0] = (fgkLVChip2PosX-fgkLVChip2X/2);
+ p1[1] = fgkLVChip2PosY;
p1[2] = carLVfullThick/2 + chip2fullThick/2;
- p2[0] = orientation*(fgkLVChip2_PosX+fgkLVChip2_X/2);
- p2[1] = fgkLVChip2_PosY;
+ p2[0] = (fgkLVChip2PosX+fgkLVChip2X/2);
+ p2[1] = fgkLVChip2PosY;
p2[2] = carLVfullThick/2 + chip2fullThick/2;
- chip2.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- chip2.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- chip2.CreateAndInsertBoxCableSegment(1);
-
- Double_t chip3fullThick = fgkLVChip3_Z + fgkLVChip3_SiZ;
- AliITSv11GeomCableFlat chip3("chip3", fgkLVChip3_Y, chip3fullThick);
+ chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
+ chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
+ boxVol = chip2.CreateAndInsertBoxCableSegment(1);
+ trCard = new TGeoCombiTrans( -fgkLVChip2PosX,
+ fgkLVChip2PosY,
+ carLVfullThick/2 + chip2fullThick/2, rotAdd);
+ fCardLVR->AddNode(boxVol, 1, trCard);
+
+ Double_t chip3fullThick = fgkLVChip3Z + fgkLVChip3SiZ;
+ AliITSv11GeomCableFlat chip3("chip3", fgkLVChip3Y, chip3fullThick);
chip3.SetNLayers(2);
- chip3.SetLayer(0, fgkLVChip3_Z, plastiChip, 12);
- chip3.SetLayer(1, fgkLVChip3_SiZ, siliconChip, 8);
- chip3.SetInitialNode( (TGeoVolume *) cardLVassembly);
- p1[0] = orientation*(fgkLVChip3_PosX-fgkLVChip3_X/2);
- p1[1] = fgkLVChip3_PosY;
+ chip3.SetLayer(0, fgkLVChip3Z, plastiChip, 12);
+ chip3.SetLayer(1, fgkLVChip3SiZ, siliconChip, 8);
+ chip3.SetInitialNode( (TGeoVolume *) fCardLVL);
+ p1[0] = (fgkLVChip3PosX-fgkLVChip3X/2);
+ p1[1] = fgkLVChip3PosY;
p1[2] = -carLVfullThick/2 - chip3fullThick/2;
- p2[0] = orientation*(fgkLVChip3_PosX+fgkLVChip3_X/2);
- p2[1] = fgkLVChip3_PosY;
+ p2[0] = (fgkLVChip3PosX+fgkLVChip3X/2);
+ p2[1] = fgkLVChip3PosY;
p2[2] = -carLVfullThick/2 - chip3fullThick/2;
- chip3.AddCheckPoint( (TGeoVolume *) cardLVassembly, 0, p1, vX);
- chip3.AddCheckPoint( (TGeoVolume *) cardLVassembly, 1, p2, vX);
- chip3.CreateAndInsertBoxCableSegment(1);
-
+ chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
+ chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
+ boxVol = chip3.CreateAndInsertBoxCableSegment(1);
+ trCard = new TGeoCombiTrans( -fgkLVChip3PosX,
+ fgkLVChip3PosY,
+ -carLVfullThick/2 - chip3fullThick/2, rotAdd);
+ fCardLVR->AddNode(boxVol, 1, trCard);
// the Al pieces for heat exchange :
-
TGeoBBox *alLVcooling1 = new TGeoBBox("alLVcooling1" ,
- fgkLVcool_X1/2, fgkLVcool_Y1/2, fgkLVcool_Z1/2);
+ fgkLVcoolX1/2, fgkLVcoolY1/2, fgkLVcoolZ1/2);
TGeoTranslation *alLVcooling1Tr = new TGeoTranslation("alLVcooling1Tr",
- orientation*(fgkLVcool_X1/2+fgkLVcool_X2),
- fgkLVcoolPosY+fgkLVcool_Y1/2,
- carLVfullThick/2+chip0fullThick+fgkLVcool_Z1/2);
+ (fgkLVcoolX1/2+fgkLVcoolX2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
TGeoTranslation *alLVcooling1TrB = new TGeoTranslation("alLVcooling1TrB",
- orientation*(fgkLVcool_X1/2+fgkLVcool_X2),
- fgkLVcoolPosY+fgkLVcool_Y1/2,
- -(carLVfullThick/2+chip0fullThick+fgkLVcool_Z1/2));
+ (fgkLVcoolX1/2+fgkLVcoolX2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
TGeoVolume *vAlLVcooling1 = new TGeoVolume("vAlLVcooling1",alLVcooling1,
alCu12SDD);
//--
TGeoBBox * alLVcooling2 = new TGeoBBox("lLVcooling2" ,
- fgkLVcool_X2/2, fgkLVcool_Y2/2, fgkLVcool_Z2/2);
+ fgkLVcoolX2/2, fgkLVcoolY2/2, fgkLVcoolZ2/2);
TGeoTranslation *alLVcooling2Tr = new TGeoTranslation("alLVcooling2Tr",
- orientation*(fgkLVcool_X2/2),
- fgkLVcoolPosY+fgkLVcool_Y1/2,
- carLVfullThick/2+chip0fullThick+fgkLVcool_Z1-fgkLVcool_Z2/2);
+ (fgkLVcoolX2/2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
TGeoTranslation *alLVcooling2TrB = new TGeoTranslation("alLVcooling2TrB",
- orientation*(fgkLVcool_X2/2),
- fgkLVcoolPosY+fgkLVcool_Y1/2,
- -(carLVfullThick/2+chip0fullThick+fgkLVcool_Z1-fgkLVcool_Z2/2));
+ (fgkLVcoolX2/2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
TGeoVolume *vAlLVcooling2 = new TGeoVolume("vAlLVcooling2",alLVcooling2,
alCu12SDD);
vAlLVcooling2->SetLineColor(2);
//--
-
- Double_t alLVcool_Z3 = (fgkLVcard_CuZ+fgkLVcard_Z+2.*(fgkLVChip0_SiZ+fgkLVChip0_Z)
- +fgkLVcool_Z1*2.);
-
+ Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
+ +fgkLVcoolZ1*2.);
TGeoBBox * alLVcooling3 = new TGeoBBox("lLVcooling3" ,
- fgkLVcool_X3/2, fgkLVcool_Y3/2, alLVcool_Z3/2);
-
-
+ fgkLVcoolX3/2, fgkLVcoolY3/2, alLVcoolZ3/2);
TGeoTranslation *alLVcooling3Tr = new TGeoTranslation("alLVcooling3Tr",
- orientation*(-fgkLVcool_X3/2),
- fgkLVcoolPosY+fgkLVcool_Y1-fgkLVcool_Y3/2,
+ (-fgkLVcoolX3/2),
+ fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
0);
-
TGeoVolume *vAlLVcooling3 = new TGeoVolume("vAlLVcooling3",alLVcooling3,alCu12SDD);
vAlLVcooling3->SetLineColor(2);
- cardLVassembly->AddNode(vAlLVcooling1, 1,alLVcooling1Tr);
- cardLVassembly->AddNode(vAlLVcooling1, 2,alLVcooling1TrB);
- cardLVassembly->AddNode(vAlLVcooling2, 1,alLVcooling2Tr);
- cardLVassembly->AddNode(vAlLVcooling2, 2,alLVcooling2TrB);
- cardLVassembly->AddNode(vAlLVcooling3, 1,alLVcooling3Tr);
+ //=== screw fixing th LV card to the U cooling tube :
+ TGeoTube *littleScrew = new TGeoTube("littleScrewLV", 0, fgkLittleScrewR,
+ fgkLVcoolY3/2);
+ TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrewLV",
+ littleScrew, stainless);
+ TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
+
+ TGeoCombiTrans *cbScrew = new TGeoCombiTrans(0,0,fgkShiftLittleScrewLV,
+ rotScrew);
+ vAlLVcooling3->AddNode(vLittleScrew, 1, cbScrew);
+
+ TGeoTube *littleScrewHead = new TGeoTube("littleScrewLVhead",
+ 0, fgkLittleLVScrewHeadR,
+ fgkLittleScrewHeadH/2);
+ TGeoVolume *vLittleScrewHead = new TGeoVolume("vLittleScrewLVhead",
+ littleScrewHead, stainless);
+ vLittleScrewHead->SetLineColor(kGray);
+ TGeoCombiTrans *cbScrewHeadL = new TGeoCombiTrans( -fgkLVcoolX3/2,
+ fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
+ fgkShiftLittleScrewLV,
+ rotScrew);
+ fCardLVL->AddNode(vLittleScrewHead, 1, cbScrewHeadL);
+
+ TGeoCombiTrans *cbScrewHeadR = new TGeoCombiTrans( fgkLVcoolX3/2,
+ fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
+ fgkShiftLittleScrewLV,
+ rotScrew);
+ fCardLVR->AddNode(vLittleScrewHead, 1, cbScrewHeadR);
+
+ // adding the cooling pieces to the left card
+ fCardLVL->AddNode(vAlLVcooling1, 1,alLVcooling1Tr);
+ fCardLVL->AddNode(vAlLVcooling1, 2,alLVcooling1TrB);
+ fCardLVL->AddNode(vAlLVcooling2, 1,alLVcooling2Tr);
+ fCardLVL->AddNode(vAlLVcooling2, 2,alLVcooling2TrB);
+ fCardLVL->AddNode(vAlLVcooling3, 1,alLVcooling3Tr);
+
+ TGeoTranslation *alLVcooling1TrR = new TGeoTranslation("alLVcooling1TrR",
+ -(fgkLVcoolX1/2+fgkLVcoolX2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
+ TGeoTranslation *alLVcooling1TrBR = new TGeoTranslation("alLVcooling1TrBR",
+ -(fgkLVcoolX1/2+fgkLVcoolX2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
+ TGeoTranslation *alLVcooling2TrR = new TGeoTranslation("alLVcooling2TrR",
+ -(fgkLVcoolX2/2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
+ TGeoTranslation *alLVcooling2TrBR = new TGeoTranslation("alLVcooling2TrBR",
+ -(fgkLVcoolX2/2),
+ fgkLVcoolPosY+fgkLVcoolY1/2,
+ -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
+
+ TGeoTranslation *alLVcooling3TrR = new TGeoTranslation("alLVcooling3TrR",
+ fgkLVcoolX3/2,
+ fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
+ 0);
+ // and to the right card
+ fCardLVR->AddNode(vAlLVcooling1, 1,alLVcooling1TrR);
+ fCardLVR->AddNode(vAlLVcooling1, 2,alLVcooling1TrBR);
+ fCardLVR->AddNode(vAlLVcooling2, 1,alLVcooling2TrR);
+ fCardLVR->AddNode(vAlLVcooling2, 2,alLVcooling2TrBR);
+ fCardLVR->AddNode(vAlLVcooling3, 1,alLVcooling3TrR);
- return cardLVassembly;
+ return kTRUE;
}
-
//________________________________________________________________________
TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateHVCard(Int_t iLay){
//
fgkHVCardCapa1PosX, fgkHVCardCapa1PosY,
-fgkHVCardCeramZ/2-fgkHVCardCapa1Z/2);
-
TGeoVolumeAssembly *capa1 = new TGeoVolumeAssembly("cardHVCapa1");
capa1->AddNode(vCapa1Middle, 1,0);
capa1->AddNode(vCapa1End, 1, capa1EndTr1);
alCu12SDD);
TGeoVolume *vCardHVcool3 = new TGeoVolume("vCardHVcool3",cardHVcool3,
alCu12SDD);
- // This last volume should in fact contains the screw used for fixing
+ // This last volume contains the screw used for fixing
// the card to the cooling tube ...
+ TGeoTube *littleScrewHV = new TGeoTube("littleScrewHV", 0, fgkLittleScrewR,
+ fgkHVCardCool3Y/2);
+ TGeoVolume *vLittleScrewHV = new TGeoVolume("vLittleScrewHV",
+ littleScrewHV, stainless);
+ TGeoRotation *rotScrewHead = new TGeoRotation("",0,90,0);
+ vCardHVcool3->AddNode(vLittleScrewHV, 1,rotScrewHead);
vCardHVcool1->SetLineColor(2); //red
vCardHVcool2->SetLineColor(2); //red
highVCard->AddNode(vCardHVcool3, 1, cool3Tr1);
highVCard->AddNode(vCardHVcool3, 2, cool3Tr2);
+ //====================================
+ //--- screws
+ TGeoCombiTrans *cbScrewHead1 = new TGeoCombiTrans("cardHVscrewHeadTr1",
+ fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2,
+ -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
+ fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
+ rotScrewHead);
+ TGeoCombiTrans *cbScrewHead2 = new TGeoCombiTrans("cardHVscrewHeadTr2",
+ -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2,
+ -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
+ fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
+ rotScrewHead);
+
+ highVCard->AddNode(fCommonVol[0], 1, cbScrewHead1);
+ highVCard->AddNode(fCommonVol[0], 2, cbScrewHead2);
+
return highVCard;
}
// and their cooling system
//
- TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- TGeoMedium *phynoxSDD = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!
+ TGeoMedium *phynoxSDD = GetMedium("INOX$");
TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
TGeoVolumeAssembly *endLadderCards = new TGeoVolumeAssembly("endLadderCards");
- //**********************************
+ //=*********************************
//--- The rounded pipe for the end ladder card coooling
Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
- endLadderPipe.CreateAndInsertCableSegment( 1);
+ //endLadderPipe.CreateAndInsertCableSegment( 1);
+ endLadderPipe.CreateAndInsertTubeSegment( 1);
//endLadderPipe.CreateAndInsertCableSegment( 2);
endLadderPipe.CreateAndInsertTorusSegment( 2);
- endLadderPipe.CreateAndInsertCableSegment( 3);
+ //endLadderPipe.CreateAndInsertCableSegment( 3);
+ endLadderPipe.CreateAndInsertTubeSegment( 3);
//endLadderPipe.CreateAndInsertCableSegment( 4);
endLadderPipe.CreateAndInsertTorusSegment( 4);
- endLadderPipe.CreateAndInsertCableSegment( 5);
+ //endLadderPipe.CreateAndInsertCableSegment( 5);
+ endLadderPipe.CreateAndInsertTubeSegment( 5);
TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
- //**********************************
+ //=*********************************
//--- LV cards
- TGeoVolumeAssembly *cardLVassemblyR = CreateLVCard(-1);
- TGeoVolumeAssembly *cardLVassemblyL = CreateLVCard( 1);
+ TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
+ TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
Double_t spaceBetweenCards = 0.2*fgkmm;
Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
+fgkEndLadPipeArmBoxDX);
- Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcool_Y1+fgkLVcool_Y3
+ Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
+fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
- Double_t alLVcool_Z3 = (fgkLVcard_CuZ+fgkLVcard_Z+2.*(fgkLVChip0_SiZ+fgkLVChip0_Z)
- +fgkLVcool_Z1*2.);
+ Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
+ +fgkLVcoolZ1*2.);
- Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcool_Z3/2
+ Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
+coolUzPos+1.25*fgkmm;
// Position in z of the first LVB with respect to the start of the cooling
// rectangular arm, coming (from inside of the ladder)
for (Int_t iCard=0; iCard<nCards; iCard++) {
Double_t cardLVzShift = firstLVCardZ +
- Double_t(iCard)*(alLVcool_Z3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
+ Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
cardLVyShift, cardLVzShift);
endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
}
- //**********************************
+ //=*********************************
//--- HV cards
- TGeoVolumeAssembly *cardHV = CreateHVCard(0);
+ TGeoVolumeAssembly *cardHV = fCardHV;
Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
+ fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
for (Int_t iCard=0; iCard<nCards; iCard++) {
Double_t fact = iCard*2.+1.;
- Double_t coolHVdz = (firstLVCardZ + alLVcool_Z3*fact/2 + spaceBetweenCards*fact
+ Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
+ fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy, coolHVdz);
endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
}
+ //=*********************************
+ //--- Carlos card
+ TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
+// TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
+// 0, -fgkCarlosSuppAngle, 0);
+ Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
+ Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
+ fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
+ // position in z of the first Carlos board, coming from inside of the ladder
+ Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 +
+ fgkEndLadPipeArmBoxDY);
+ for (Int_t iCard=0; iCard<nCards; iCard++) {
+ Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
+ iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
+ TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy,carloszPos,
+ (TGeoRotation*) fCommonTr[0]);
- //**********************************
- //--- Carlos cards
+ endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
+ }
-// TGeoVolumeAssembly *carlosCardAssemblyR = CreateCarlosCard(-1);
-// TGeoVolumeAssembly *carlosCardAssemblyL = CreateCarlosCard( 1);
+ return endLadderCards;
+}
-// endLadderCards->AddNode(carlosCardAssemblyR, 1, 0);
+//________________________________________________________________________
+TGeoVolume* AliITSv11GeometrySDD::CreateEndLadderCardsV(Int_t iLay) {
+//
+// return an Pcon containing the LV, HV and Carlos cards of one ladder
+// and their cooling system
+// This is the code actually used for the end ladder cards
+//
- //**********************************
- //--- support for Carlos card
+ TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!
+ TGeoMedium *phynoxSDD = GetMedium("INOX$");
+ TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
+ TGeoMedium *copper = GetMedium("COPPER$");
+ TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ???
+ TGeoMedium *airSDD = GetMedium("SDD AIR$");
+ TGeoMedium *opticalFiber = GetMedium("SDD SI insensitive$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- TGeoVolumeAssembly *assemblySupCarlos = new TGeoVolumeAssembly("assemblySupCarlos");
+ Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
+ Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3;
+ Int_t nCards = 3;
+ Double_t rREF = fgkEndLaddCardsShortRadiusLay3;
+ // reference radius corresponding to local y=0
- TGeoBBox *supCarlosBoard1 = new TGeoBBox("",fgkCarlosSuppX1/2,fgkCarlosSuppY1/2,
- fgkCarlosSuppZ/2);
- TGeoBBox *supCarlosBoard2 = new TGeoBBox("",fgkCarlosSuppX2/2,fgkCarlosSuppY2/2,
- fgkCarlosSuppZ/2);
- TGeoBBox *supCarlosBoard3 = new TGeoBBox("",fgkCarlosSuppX3/2,fgkCarlosSuppY3/2,
- fgkCarlosSuppZ3/2);
+ if (iLay==4) {
+ endLadPipeUlength = fgkEndLadPipeUlengthLay4;
+ endLadPipeArmZ = fgkEndLadPipeArmZLay4;
+ nCards = 4;
+ rREF = fgkEndLaddCardsShortRadiusLay4;
+ }
- TGeoVolume *vSupCarlosBoard1 = new TGeoVolume("vSupCarlosBoard1",
- supCarlosBoard1, alCu12SDD);
- TGeoVolume *vSupCarlosBoard2 = new TGeoVolume("vSupCarlosBoard2",
- supCarlosBoard2, alCu12SDD);
- TGeoVolume *vSupCarlosBoard3 = new TGeoVolume("vSupCarlosBoard3",
- supCarlosBoard3, alCu12SDD);
- vSupCarlosBoard1->SetLineColor(4);
- vSupCarlosBoard2->SetLineColor(4);
- vSupCarlosBoard3->SetLineColor(4);
+ Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
+ +fgkEndLadPipeArmBoxDX);
+ Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
+ +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
- TGeoRotation *carlosSupRot1 = new TGeoRotation("", 0, -fgkCarlosSuppAngle, 0);
+ Double_t rMin = rREF + cardLVyShift;
+ // (The LV card is defining rMin because it is the lower object)
- Double_t shift = fgkCarlosSuppY2/2-fgkCarlosSuppY1/2;
+ Double_t thickTotCable = 0.5;
- Double_t shiftGlob = -fgkCarlosSuppZ/2+fgkCarlosSuppTopLen;
- shiftGlob+= 0.5*fgkCarlosSuppY3/cos((90-fgkCarlosSuppAngle)*TMath::DegToRad());
- shiftGlob-= 0.5*fgkCarlosSuppY2*tan((90-fgkCarlosSuppAngle)*TMath::DegToRad());
- Double_t shiftGlobY = shiftGlob*sin(fgkCarlosSuppAngle*TMath::DegToRad());
- Double_t shiftGlobZ = shiftGlob*cos(fgkCarlosSuppAngle*TMath::DegToRad());
+ //==================================
+ //--- The Pcon container
+
+ // minimum angle of the Pcon :
+ Double_t tanDPhi = ((fgkEndLadPipeUwidth/2+fgkEndLadPipeArmX/2) /
+ (rREF-fgkEndLadPipeArmY/2) );
+ Double_t dphi = 2*TMath::ATan(tanDPhi)*TMath::RadToDeg();
+ Double_t phi0 = 90-dphi/2;
+ Double_t coolUzPos = fgkEndLadPipeOuterDiam/2 + fgkDistEndLaddCardsLadd; // it is the z coord of the axis
+ // of the U colling pipe in its center
+ Double_t zMax = endLadPipeUlength+coolUzPos;
+ Double_t rMax = rMin + fgkLVcardY;
+ rMax = TMath::Sqrt(rMax*rMax + cardLVxShift*cardLVxShift);
+ Double_t cablesRadius = rMax-0.5;
+
+ TGeoPcon *containerShape = new TGeoPcon("EndLadderCcontainerShape", phi0, dphi, 10);
+ //DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
+ // hard coded numbers are fine tuning to avoid overlaps with other volume in the old geometry
+ containerShape->DefineSection(0, fgkDistEndLaddCardsLadd, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
+ containerShape->DefineSection(1, fgkDistEndLaddCardsLadd+1.4, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
+ containerShape->DefineSection(2, fgkDistEndLaddCardsLadd+1.4, rMin, rMax);
+ containerShape->DefineSection(3, endLadPipeArmZ+2*fgkEndLadPipeRadius, rMin, rMax);
+ containerShape->DefineSection(4, endLadPipeArmZ+2*fgkEndLadPipeRadius, rREF-1.*fgkmm, rMax);
+ containerShape->DefineSection(5, zMax, rREF-1.*fgkmm, rMax);
+ // the following is quite dirty but works for the moment ...
+ containerShape->DefineSection(6, zMax, rREF+fgkCarlosCardZ1/2, rMax);
+ containerShape->DefineSection(7, zMax+1, cablesRadius-thickTotCable/2, rMax);
+
+ // The next parameters define the shape of the Pcon at its end and where cables
+ // are escaping...
+ Double_t cableSectionR1 = cablesRadius-thickTotCable/2;
+ Double_t cableSectionR2 = rMax;
+ Double_t cableSectionZ1 = zMax + 6.3*fgkmm + 2.5*fgkcm;
+ Double_t cableSectionZ2 = zMax + 7.3*fgkmm + 4*fgkcm;
+ // Those 6.3 and 7.3 are to be fixed to stick the maximum to the SDD cone
+ // (I'm waiting for the new cone)
+
+ containerShape->DefineSection(8, cableSectionZ1, cableSectionR1, rMax);
+ containerShape->DefineSection(9, cableSectionZ2, cableSectionR2, rMax);
+
+ TGeoVolume *endLadderCards = new TGeoVolume("endLadderCards",containerShape,airSDD);
+ //endLadderCards->SetVisibility(kFALSE);
+
+ //=*********************************
+ //--- The rounded pipe for the end ladder card cooling
- TGeoCombiTrans *carlosSupTr1 = new TGeoCombiTrans( -fgkCarlosSuppX2/2,
- shift*cos(fgkCarlosSuppAngle*TMath::DegToRad())+shiftGlobY,
- -shift*sin(fgkCarlosSuppAngle*TMath::DegToRad())+shiftGlobZ,
- carlosSupRot1);
+ AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
+ endLadderPipe.SetNLayers(2);
+ endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
+ endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
- TGeoCombiTrans *carlosSupTr2 = new TGeoCombiTrans( fgkCarlosSuppX1/2,
- shiftGlobY,
- shiftGlobZ,
- carlosSupRot1);
+ Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos};
+ Double_t vectA[3] = {0,0,1};
- TGeoTranslation *carlosSupTr3 = new TGeoTranslation((fgkCarlosSuppX1+
- fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0);
- TGeoTranslation *carlosSupTr4 = new TGeoTranslation(-(fgkCarlosSuppX1+
- fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0);
+ Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos};
+ Double_t vectB[3] = {0,0,1};
- assemblySupCarlos->AddNode(vSupCarlosBoard1, 0, carlosSupTr1);
- assemblySupCarlos->AddNode(vSupCarlosBoard2, 0, carlosSupTr2);
- assemblySupCarlos->AddNode(vSupCarlosBoard3, 0, carlosSupTr3);
- assemblySupCarlos->AddNode(vSupCarlosBoard3, 1, carlosSupTr4);
+ Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, rREF, coolUzPos};
+ Double_t vectC[3] = {1,0,0};
+
+ Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, rREF, coolUzPos};
+ Double_t vectD[3] = {-1,0,0};
+
+ Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, rREF, fgkEndLadPipeRadius+coolUzPos};
+ Double_t vectE[3] = {0,0,-1};
+
+ Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,rREF, endLadPipeUlength+coolUzPos};
+ Double_t vectF[3] = {0,0,-1};
+
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
+ endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
+
+ endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
+ //endLadderPipe.CreateAndInsertCableSegment( 1);
+ endLadderPipe.CreateAndInsertTubeSegment( 1);
+ //endLadderPipe.CreateAndInsertCableSegment( 2);
+ endLadderPipe.CreateAndInsertTorusSegment( 2);
+ //endLadderPipe.CreateAndInsertCableSegment( 3);
+ endLadderPipe.CreateAndInsertTubeSegment( 3);
+ //endLadderPipe.CreateAndInsertCableSegment( 4);
+ endLadderPipe.CreateAndInsertTorusSegment( 4);
+ //endLadderPipe.CreateAndInsertCableSegment( 5);
+ endLadderPipe.CreateAndInsertTubeSegment( 5);
+
+ TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
+ fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
+ TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
+ fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
+
+ TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
+ - fgkEndLadPipeArmBoxDX,
+ fgkEndLadPipeArmBoxDY,0);
+ TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
+ fgkEndLadPipeArmBoxDX,
+ fgkEndLadPipeArmBoxDY,0);
+ endLadPipeArmBoxDY1->RegisterYourself();
+ endLadPipeArmBoxDY2->RegisterYourself();
+
+ if(GetDebug(3)) { // Remove compiler warning.
+ endLadPipeArmBox->InspectShape();
+ endLadPipeArmTube->InspectShape();
+ }
+
+ TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
+ "endLadPipeArmBox:endLadPipeArmBoxDY1"
+ "- endLadPipeArmTube");
+ TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
+ "endLadPipeArmBox:endLadPipeArmBoxDY2"
+ "- endLadPipeArmTube");
+
+ TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
+ endLadPipeArm1, alCu12SDD);
+ TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
+ endLadPipeArm2, alCu12SDD);
+ vEndLadPipeArm1->SetLineColor(2);
+ vEndLadPipeArm2->SetLineColor(2);
+
+ Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
+ +fgkEndLadPipeArmZpos);
+
+ TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
+ -fgkEndLadPipeUwidth/2,rREF,armZ);
+ TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
+ fgkEndLadPipeUwidth/2,rREF,armZ);
+
+ endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
+ endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
+
+ //=*********************************
+ //--- LV cards
+ TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
+ TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
+
+ Double_t spaceBetweenCards = 0.2*fgkmm;
+
+
+ Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
+ +fgkLVcoolZ1*2.);
+
+ Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
+ +coolUzPos+1.25*fgkmm;
+ // Position in z of the first LVB with respect to the start of the cooling
+ // rectangular arm, coming (from inside of the ladder)
+ // The cards are added one after the other
+
+ for (Int_t iCard=0; iCard<nCards; iCard++) {
+
+ Double_t cardLVzShift = firstLVCardZ +
+ Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
+
+ TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
+ cardLVyShift+rREF, cardLVzShift);
+ TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
+ cardLVyShift+rREF, cardLVzShift);
+
+ endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
+ endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
+ }
+
+ //=*********************************
+ //--- HV cards
+ TGeoVolumeAssembly *cardHV = fCardHV;
+
+ Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
+ + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
+ // shift of the HV card in local y w.r.t the local y=0 (center of cooling tube)
+
+ Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
+ -(fgkHVCardCeramZ)/2);
+
+ for (Int_t iCard=0; iCard<nCards; iCard++) {
+
+ Double_t fact = iCard*2.+1.;
+ Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
+ + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
+ TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy+rREF, coolHVdz);
+ endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
+ }
+
+ //=*********************************
+ //--- Carlos card
+
+ TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
+// TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
+// 0, -fgkCarlosSuppAngle, 0);
Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
- Double_t firstCarlosCardZ = (firstLVCardZ - alLVcool_Z3/2 + alLVcool_Z3*4 +
+ Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
// position in z of the first Carlos board, coming from inside of the ladder
for (Int_t iCard=0; iCard<nCards; iCard++) {
- Double_t carloszPos = firstCarlosCardZ + fgkCarlosSuppZ3/2
- +iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards);
- TGeoTranslation *carlosPos = new TGeoTranslation(0,coolCarlosDy,carloszPos);
+ Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
+ iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
+ TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy+rREF,carloszPos,
+ (TGeoRotation*) fCommonTr[0]);
+
endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
}
+ //=*********************************
+ //--- Cables
-
- /*
- //==================================
- //--- test of flat cable curvature
- //==================================
+ Double_t sectionV = (fgkSectionCuPerMod+fgkSectionPlastPerMod
+ + fgkSectionGlassPerMod)*nCards;
+ // We fix thickness, then width is calculated accordingly
+ Double_t width = sectionV/thickTotCable;
+ Double_t thickCu = thickTotCable*fgkSectionCuPerMod
+ / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod);
+ Double_t thickPlast = thickTotCable*fgkSectionPlastPerMod
+ / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod);
+ Double_t thickGlass = thickTotCable - thickCu - thickPlast;
- double angle = 90;
- AliITSv11GeomCableFlat cable("test", 3, 0.3);
- cable.SetNLayers(1);
- cable.SetNLayers(2);
- cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
- cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
- cable.SetInitialNode(endLadderCards);
+ AliITSv11GeomCableFlat cable("SDDcableEndLadder",width,thickTotCable);
+ cable.SetNLayers(3);
+ cable.SetLayer(0, thickCu, copper, kRed);
+ cable.SetLayer(1, thickPlast, plastic, kYellow);
+ cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
- Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
+ Double_t zVect[3]={0,0,1};
+ Double_t xMinCable = firstCarlosCardZ+nCards*(fgkCarlosSuppZ3
+ +spaceBetweenCarlsoCards)/2 + 2.9;
+ // the 2.9cm is for taking into account carlos card angle...
- p1[0] = -3;
- p1[1] = 1;
- p1[2] = 10;
+ Double_t zEndCable = GetConeZ(cablesRadius-thickTotCable/2, cableSectionR1,
+ cableSectionR2,cableSectionZ1,cableSectionZ2);
- p2[0] = 0;
- p2[1] = 1;
- p2[2] = 10;
- cable.AddCheckPoint(endLadderCards, 0, p1, vX);
- cable.AddCheckPoint(endLadderCards, 1, p2, vX);
- cable.CreateAndInsertBoxCableSegment(1,angle);
-
- Double_t p3[3], p4[3];
-
- p3[0] = 2;
- p3[1] = 3;
- p3[2] = 10;
- cable.AddCheckPoint(endLadderCards, 2, p3, vY);
- cable.CreateAndInsertCableCylSegment(2,angle);
-
- p4[0] = 2;
- p4[1] = 6;
- p4[2] = 10;
- cable.AddCheckPoint(endLadderCards, 3, p4, vY);
- cable.CreateAndInsertCableSegment(3,angle);
- */
+ Double_t pos1[3] = {0, cablesRadius, xMinCable};
+ Double_t pos2[3] = {0, cablesRadius, zEndCable};
+ cable.AddCheckPoint( endLadderCards, 0, pos1, zVect );
+ cable.AddCheckPoint( endLadderCards, 1, pos2, zVect );
+ cable.SetInitialNode(endLadderCards);
+ cable.CreateAndInsertCableSegment(1);
return endLadderCards;
}
TGeoBBox *rubyCageInternBox = new TGeoBBox("rubyCageInternBox",fgkRubyCageInternSide/2,
fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2);
- TGeoTube *ScrewHole = new TGeoTube("screwHole", 0, fgkRubyCageScrewHoleR,
+ TGeoTube *screwHole = new TGeoTube("screwHole", 0, fgkRubyCageScrewHoleR,
fgkRubyCageHoleDX/2+epsilon);
TGeoRotation *rotV = new TGeoRotation("", 90,90,-90);
if(GetDebug(3)) { // Remove compiler warning.
rubyCageBox->InspectShape();
rubyCageInternBox->InspectShape();
- ScrewHole->InspectShape();
+ screwHole->InspectShape();
screwHoleFoot->InspectShape();
rubyCageVInternBox->InspectShape();
rubyCageVInternTriangl->InspectShape();
x2[2] = 0;
transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
- transitHVCable.CreateAndInsertBoxCableSegment(1,-90);
+ segment = transitHVCable.CreateAndInsertBoxCableSegment(1,-90,&ctSegment);
+ fSDDsensor4->AddNode(segment, 1, ctSegment);
+
transitHVCable.ResetPoints();
transitHVCable.SetName("ITSsddHVtransitTail");
transitHVCable.SetWidth(fgkTransitHVtailWidth);
sideLeftAl->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
sideLeftAl->SetVertex(7, fgkTransitHVHeadLX/2, 0);
- TGeoArb8 *sideRight = new TGeoArb8( fgkTransitHVPolyThick/2 );
- sideRight->SetVertex(0, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
- sideRight->SetVertex(1, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
- fgkTransitHVsideLZ);
- sideRight->SetVertex(2, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
- sideRight->SetVertex(3, -fgkTransitHVHeadLX/2, 0);
- sideRight->SetVertex(4, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
- sideRight->SetVertex(5, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
- fgkTransitHVsideLZ);
- sideRight->SetVertex(6, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
- sideRight->SetVertex(7, -fgkTransitHVHeadLX/2, 0);
+ // sideRight is not there actually
+// TGeoArb8 *sideRight = new TGeoArb8( fgkTransitHVPolyThick/2 );
+// sideRight->SetVertex(0, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
+// sideRight->SetVertex(1, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
+// fgkTransitHVsideLZ);
+// sideRight->SetVertex(2, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
+// sideRight->SetVertex(3, -fgkTransitHVHeadLX/2, 0);
+// sideRight->SetVertex(4, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
+// sideRight->SetVertex(5, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
+// fgkTransitHVsideLZ);
+// sideRight->SetVertex(6, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
+// sideRight->SetVertex(7, -fgkTransitHVHeadLX/2, 0);
// TGeoRotation rotSide("",0,-90,0);
// TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
// fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
// -fgkTransitHVBondingLZ/2, &rotSide);
TGeoRotation *rotSide = new TGeoRotation("",0,-90,0);
- TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
- (fgkWaferThickness+fgkTransitHVPolyThick)/2,
- -fgkTransitHVBondingLZ/2,rotSide);
+// TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
+// (fgkWaferThickness+fgkTransitHVPolyThick)/2,
+// -fgkTransitHVBondingLZ/2,rotSide);
TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
(fgkWaferThickness+fgkTransitHVPolyThick)/2,
-fgkTransitHVBondingLZ/2, rotSide);
fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
-fgkTransitHVBondingLZ/2, rotSide);
-
TGeoVolume *vSideLeft = new TGeoVolume("ITSsddHVtransitSideLeft",
sideLeft,polyhamideSDD);
vSideLeft->SetLineColor(fColorPolyhamide);
TGeoVolume *vSideLeftAl = new TGeoVolume("ITSsddHVtransitSideLeftAl",
sideLeftAl,alSDD);
vSideLeftAl->SetLineColor(fColorAl);
- TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight",
- sideRight,polyhamideSDD);
- vSideRight->SetLineColor(fColorPolyhamide);
+
+// TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight",
+// sideRight,polyhamideSDD);
+// vSideRight->SetLineColor(fColorPolyhamide);
fSDDsensor3->AddNode(vSideLeft, 1, sideLeftTr);
fSDDsensor3->AddNode(vSideLeftAl, 1, sideLeftAlTr);
- fSDDsensor3->AddNode(vSideRight, 1, sideRightTr);
+// fSDDsensor3->AddNode(vSideRight, 1, sideRightTr);
fSDDsensor4->AddNode(vSideLeft, 1, sideLeftTr);
fSDDsensor4->AddNode(vSideLeftAl, 1, sideLeftAlTr);
- fSDDsensor4->AddNode(vSideRight, 1, sideRightTr);
+// fSDDsensor4->AddNode(vSideRight, 1, sideRightTr);
};
//****************************
if (iLay==3) if (i%2!=0) localY = -localY;
if (iLay==4) if (i%2==0) localY = -localY;
sprintf(name, "ITSsddLay%iSensorPos%i",iLay, i);
-
+
if (i >= nDetectors/2) {
TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
sensorPos->SetName(name);
return kTRUE;
}
+
+
+//________________________________________________________________________
+TGeoPcon* AliITSv11GeometrySDD::CreateConeConstSection(Double_t r1max, Double_t z1,
+ Double_t r2max, Double_t z2,
+ Double_t section, Int_t nDiv)
+{
+ // Creates a cone along z where the section is approximately constant
+ // with z. This is for simulation of cables, because a cone with a constant
+ // radius difference would show a quantity of matter increasing with z...
+ // The max radius of the created Pcon is evolving linearly, the min radius
+ // is calculated at several steps (nDiv).
+ // z2 > z1 (required by the Pcon)
+
+ TGeoPcon *myPcon = new TGeoPcon(0, 360, 1+nDiv);
+
+ Double_t dr = (r2max-r1max)/nDiv;
+ Double_t dz = (z2-z1)/nDiv;
+ Double_t r1minI, r2minI, r1maxI, r2maxI;
+ Double_t z1I, z2I;
+
+ Double_t lZ = TMath::Sqrt((r2max-r1max)*(r2max-r1max) + (z2-z1)*(z2-z1));
+ Double_t cosAlpha = (z2-z1)/lZ;
+
+ r1minI = TMath::Sqrt(r1max*r1max-section/(TMath::Pi()*cosAlpha));
+ myPcon->DefineSection(0, z1, r1minI, r1max);
+
+ for (Int_t i=0; i<nDiv; i++) {
+
+ z1I = z1 + i*dz;
+ z2I = z1I + dz;
+ r1maxI = r1max + i*dr;
+ r2maxI = r1maxI + dr;
+
+ r2minI = TMath::Sqrt(r2maxI*r2maxI-section/(TMath::Pi()*cosAlpha));
+ myPcon->DefineSection(i+1, z2I, r2minI, r2maxI);
+ }
+ return myPcon;
+}
+
+
+//________________________________________________________________________
+Double_t AliITSv11GeometrySDD::GetConeZ(Double_t r, Double_t refR1, Double_t refR2,
+ Double_t refZ1, Double_t refZ2) {
+ // just a helping function
+ return refZ1+(refZ2-refZ1)*(r-refR1)/(refR2-refR1);
+}
+
+//________________________________________________________________________
+Int_t AliITSv11GeometrySDD::CreateAndInsetConeCablePart(TGeoVolume *mother, Double_t angle,
+ Int_t nLay3, Int_t nLay4,
+ Double_t r1, Double_t z1,
+ Double_t r2, Double_t z2) {
+
+ // Create some cables portions from SDD modules grouped
+ // and attached at the border of the SSD cone
+
+ TGeoMedium *copper = GetMedium("COPPER$");
+ TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ???
+ TGeoMedium *opticalFiber = GetMedium("SDD SI insensitive$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+ char titleCable[30];
+ sprintf(titleCable,"cableSDDport%i",(Int_t)angle);
+
+ //---
+ Double_t section = (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod)*(nLay3+nLay4);
+ Double_t thickness = 1.; // let's fix the thickness, then calculate the width
+ Double_t width = section/thickness;
+ Double_t thickCu = thickness*fgkSectionCuPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
+ +fgkSectionGlassPerMod);
+
+ Double_t thickPlast = thickness*fgkSectionPlastPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
+ +fgkSectionGlassPerMod);
+
+ Double_t thickGlass = thickness*fgkSectionGlassPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
+ +fgkSectionGlassPerMod);
+
+ Double_t hypothenus = TMath::Sqrt( (r2-r1)*(r2-r1) + (z2-z1)*(z2-z1) );
+ Double_t cosAlpha = (z2-z1)/hypothenus;
+ Double_t radius1Cable = TMath::Sqrt(r1*r1 - width*width/4) - 0.5*thickness/cosAlpha;
+ Double_t radius2Cable = TMath::Sqrt(r2*r2 - width*width/4) - 0.5*thickness/cosAlpha;
+ angle *= TMath::DegToRad();
+ Double_t x1 = radius1Cable*TMath::Cos(angle), y1 = radius1Cable*TMath::Sin(angle);
+ Double_t x2 = radius2Cable*TMath::Cos(angle), y2 = radius2Cable*TMath::Sin(angle);
+ Double_t pos1[3] = {x1,y1,z1};
+ Double_t pos2[3] = {x2,y2,z2};
+ Double_t zVect[3] = {0,0,1};
+
+ AliITSv11GeomCableFlat cable(titleCable,width,thickness);
+ cable.SetNLayers(3);
+ cable.SetLayer(0, thickPlast, plastic, kYellow);
+ cable.SetLayer(1, thickCu, copper, kRed);
+ cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
+
+ cable.AddCheckPoint( mother, 0, pos1, zVect );
+ cable.AddCheckPoint( mother, 1, pos2, zVect );
+ cable.SetInitialNode(mother);
+ cable.CreateAndInsertCableSegment(1);
+
+ return kTRUE;
+}
+
+
+
+//________________________________________________________________________
+void AliITSv11GeometrySDD::SDDCables(TGeoVolume *moth) {
+
+ // Creates and inserts the SDD cables running on SDD and SSD cones
+
+ TGeoMedium *copper = GetMedium("COPPER$");
+ TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ???
+ TGeoMedium *opticalFiber = GetMedium("SDD SI insensitive$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ TGeoMedium *airSDD = GetMedium("SDD AIR$");
+
+
+ //==================================
+ //
+ //==================================
+
+ Double_t nModLay3 = fgkLay3Nladd*fgkLay3Ndet;
+ Double_t nModLay4 = fgkLay4Nladd*fgkLay4Ndet;
+
+ Double_t sectionLay3Cu = fgkCableBendRatio*fgkSectionCuPerMod*nModLay3/2;
+ Double_t sectionLay3Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay3/2;
+ Double_t sectionLay3Glass = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay3/2;
+
+ Double_t sectionLay4Cu = fgkCableBendRatio*fgkSectionCuPerMod*nModLay4/2;
+ Double_t sectionLay4Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay4/2;
+ Double_t sectionLay4Glass = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay4/2;
+
+ // calculate z1, z2 thanks to R1 and R2
+ Double_t sddCableZ1 = GetConeZ(fgkSDDCableR1, fgkConeSDDr1,fgkConeSDDr2,fgkConeSDDz1,fgkConeSDDz2);
+ Double_t sddCableZ2 = GetConeZ(fgkSDDCableR2, fgkConeSDDr1,fgkConeSDDr2,fgkConeSDDz1,fgkConeSDDz2);
+ Double_t sddCableZ3 = GetConeZ(fgkSDDCableR3, fgkConeSDDr1,fgkConeSDDr2,fgkConeSDDz1,fgkConeSDDz2);
+
+ TGeoRotation *rotCableSDD = new TGeoRotation("rotCableSDD",0,180,0);
+
+ //==================================
+ // first set of cones : cables from layer 3
+ //==================================
+
+ TGeoPcon* pcon1all = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
+ fgkSDDCableR2, sddCableZ2,
+ sectionLay3Plastic+sectionLay3Cu+sectionLay3Glass, 1);
+
+ TGeoPcon* pcon1container = new TGeoPcon(0,360,2);
+ pcon1container->DefineSection(0, sddCableZ1, pcon1all->GetRmin(0), pcon1all->GetRmax(0));
+ Double_t drMax = pcon1all->GetRmax(0)- pcon1all->GetRmin(0);
+ pcon1container->DefineSection(1, sddCableZ2, pcon1all->GetRmax(1)-drMax, pcon1all->GetRmax(1));
+ delete pcon1all;
+ TGeoVolume *vpcon1container = new TGeoVolume("vpcon1container", pcon1container, airSDD);
+ vpcon1container->SetVisibility(kFALSE);
+
+ TGeoPcon* pcon1plast = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
+ fgkSDDCableR2, sddCableZ2,
+ sectionLay3Plastic, 3);
+ TGeoVolume *vpcon1plast = new TGeoVolume("ITScablesSDDpcon1Plast", pcon1plast, plastic);
+ vpcon1plast->SetLineColor(kYellow);
+ vpcon1container->AddNode(vpcon1plast, 0);
+
+ Double_t dr1a = fgkSDDCableR1 - pcon1plast->GetRmin(0);
+ TGeoPcon* pcon1Cu = CreateConeConstSection(fgkSDDCableR1 - dr1a, sddCableZ1,
+ fgkSDDCableR2 - dr1a, sddCableZ2,
+ sectionLay3Cu, 3);
+ TGeoVolume *vpcon1Cu = new TGeoVolume("ITScablesSDDpcon1Cu", pcon1Cu, copper);
+ vpcon1Cu->SetLineColor(kRed);
+ vpcon1container->AddNode(vpcon1Cu, 0);
+ //moth->AddNode(vpcon1Cu, 0);
+
+ //---
+ Double_t dr1b = pcon1Cu->GetRmax(0) - pcon1Cu->GetRmin(0);
+ TGeoPcon* pcon1glass = CreateConeConstSection(fgkSDDCableR1-dr1a-dr1b, sddCableZ1,
+ fgkSDDCableR2-dr1a-dr1b, sddCableZ2,
+ sectionLay3Glass, 3);
+ TGeoVolume *vpcon1glass = new TGeoVolume("ITScablesSDDpcon1glass", pcon1glass, opticalFiber);
+ vpcon1glass->SetLineColor(kGreen);
+ vpcon1container->AddNode(vpcon1glass, 0);
+
+ moth->AddNode(vpcon1container, 0);
+ moth->AddNode(vpcon1container, 1, rotCableSDD);
+
+ //==================================
+ // 2nd set of cones : cables from layer 3 and layer 4
+ //==================================
+
+ TGeoPcon* pcon2all = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
+ fgkSDDCableR3, sddCableZ3,
+ sectionLay3Plastic+sectionLay4Plastic+
+ sectionLay3Cu+sectionLay4Cu+
+ sectionLay3Glass+sectionLay4Glass, 1);
+ TGeoPcon* pcon2container = new TGeoPcon(0,360,2);
+ pcon2container->DefineSection(0, sddCableZ2, pcon2all->GetRmin(0), pcon2all->GetRmax(0));
+ drMax = pcon2all->GetRmax(0)- pcon2all->GetRmin(0);
+ pcon2container->DefineSection(1, sddCableZ3, pcon2all->GetRmax(1)-drMax, pcon2all->GetRmax(1));
+ delete pcon2all;
+ TGeoVolume *vpcon2container = new TGeoVolume("vpcon2container", pcon2container, airSDD);
+ vpcon2container->SetVisibility(kFALSE);
+
+ TGeoPcon* pcon2plast = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
+ fgkSDDCableR3, sddCableZ3,
+ sectionLay3Plastic+sectionLay4Plastic, 3);
+ TGeoVolume *vpcon2plast = new TGeoVolume("ITScablesSDDpcon2Plast", pcon2plast, plastic);
+ vpcon2plast->SetLineColor(kYellow);
+ vpcon2container->AddNode(vpcon2plast, 0);
+
+ Double_t dr2a = fgkSDDCableR2 - pcon2plast->GetRmin(0);
+ TGeoPcon* pcon2Cu = CreateConeConstSection(fgkSDDCableR2 - dr2a, sddCableZ2,
+ fgkSDDCableR3 - dr2a, sddCableZ3,
+ sectionLay3Cu+sectionLay4Cu, 3);
+ TGeoVolume *vpcon2Cu = new TGeoVolume("ITScablesSDDpcon2Cu", pcon2Cu, copper);
+ vpcon2Cu->SetLineColor(kRed);
+ vpcon2container->AddNode(vpcon2Cu, 0);
+
+ //---
+ Double_t dr2b = pcon2Cu->GetRmax(0) - pcon2Cu->GetRmin(0);
+ TGeoPcon* pcon2glass = CreateConeConstSection(fgkSDDCableR2-dr2a-dr2b, sddCableZ2,
+ fgkSDDCableR3-dr2a-dr2b, sddCableZ3,
+ sectionLay3Glass+sectionLay4Glass, 3);
+ TGeoVolume *vpcon2glass = new TGeoVolume("ITScablesSDDpcon2glass", pcon2glass, opticalFiber);
+ vpcon2glass->SetLineColor(kGreen);
+ vpcon2container->AddNode(vpcon2glass, 0);
+
+ moth->AddNode(vpcon2container, 0);
+ moth->AddNode(vpcon2container, 1, rotCableSDD);
+
+ //==================================
+ // intermediate cylinder
+ //==================================
+
+ TGeoTube *interCyl = new TGeoTube("sddCableInterCyl", pcon2container->GetRmin(1),
+ pcon2container->GetRmax(1),
+ fgkSDDCableDZint/2);
+ TGeoVolume *vInterCyl = new TGeoVolume("vSddCableInterCyl",interCyl, airSDD);
+ vInterCyl->SetVisibility(kFALSE);
+
+ //---
+ Double_t rmaxCylPlast = pcon2container->GetRmax(1);
+ Double_t rminCylPlast = TMath::Sqrt(rmaxCylPlast*rmaxCylPlast -
+ (sectionLay3Plastic+sectionLay4Plastic)/TMath::Pi() );
+
+ TGeoTube *interCylPlast = new TGeoTube("sddCableInterCylPlast", rminCylPlast,
+ rmaxCylPlast, fgkSDDCableDZint/2);
+ TGeoVolume *vInterCylPlast = new TGeoVolume("vSddCableInterCylPlast", interCylPlast, plastic);
+ vInterCylPlast->SetLineColor(kYellow);
+ vInterCyl->AddNode(vInterCylPlast, 0);
+
+ //---
+ Double_t rmaxCylCu = pcon2Cu->GetRmax(3);
+ Double_t rminCylCu = TMath::Sqrt(rmaxCylCu*rmaxCylCu -
+ (sectionLay3Cu+sectionLay4Cu)/TMath::Pi() );
+ TGeoTube *interCylCu = new TGeoTube("sddCableInterCylCu", rminCylCu,
+ rmaxCylCu, fgkSDDCableDZint/2);
+ TGeoVolume *vInterCylCu = new TGeoVolume("vSddCableInterCylCu", interCylCu, copper);
+ vInterCylCu->SetLineColor(kRed);
+ vInterCyl->AddNode(vInterCylCu, 0);
+
+ //---
+ Double_t rmaxCylGlass = pcon2glass->GetRmax(3);
+ Double_t rminCylGlass = TMath::Sqrt(rmaxCylGlass*rmaxCylGlass -
+ (sectionLay3Glass+sectionLay4Glass)/TMath::Pi() );
+ TGeoTube *interCylGlass = new TGeoTube("sddCableInterCylGlass", rminCylGlass,
+ rmaxCylGlass, fgkSDDCableDZint/2);
+ TGeoVolume *vInterCylGlass = new TGeoVolume("vSddCableInterCylGlass",interCylGlass,opticalFiber);
+ vInterCylGlass->SetLineColor(kGreen);
+ vInterCyl->AddNode(vInterCylGlass, 0);
+
+ //---
+ TGeoTranslation *trInterCylP = new TGeoTranslation("trSddCableInterCylPos",
+ 0,0,sddCableZ3+fgkSDDCableDZint/2);
+ moth->AddNode(vInterCyl, 0,trInterCylP);
+ TGeoTranslation *trInterCylN = new TGeoTranslation("trSddCableInterCylNeg",
+ 0,0,-sddCableZ3-fgkSDDCableDZint/2);
+
+ moth->AddNode(vInterCyl, 1,trInterCylN);
+
+ //==================================
+ // cable cone on the SSD cone
+ //==================================
+
+ Double_t sddCableR4 = rmaxCylPlast;
+ Double_t sddCableZ4 = sddCableZ3+fgkSDDCableDZint;
+
+ TGeoPcon* pcon3all = CreateConeConstSection(sddCableR4, sddCableZ4,
+ fgkSDDCableR5, fgkSDDCableZ5,
+ sectionLay3Plastic+sectionLay4Plastic+
+ sectionLay3Cu+sectionLay4Cu+
+ sectionLay3Glass+sectionLay4Glass, 1);
+
+ TGeoPcon* pcon3container = new TGeoPcon(0,360,2);
+ pcon3container->DefineSection(0, sddCableZ4, pcon3all->GetRmin(0), pcon3all->GetRmax(0));
+ drMax = pcon3all->GetRmax(0) - pcon3all->GetRmin(0);
+ pcon3container->DefineSection(1, fgkSDDCableZ5, pcon3all->GetRmax(1)-drMax, pcon3all->GetRmax(1));
+ delete pcon3all;
+ TGeoVolume *vpcon3container = new TGeoVolume("vpcon3container", pcon3container, airSDD);
+ vpcon3container->SetVisibility(kFALSE);
+
+ TGeoPcon* pcon3plast = CreateConeConstSection(sddCableR4, sddCableZ4,
+ fgkSDDCableR5, fgkSDDCableZ5,
+ sectionLay3Plastic+sectionLay4Plastic, 3);
+ TGeoVolume *vpcon3plast = new TGeoVolume("ITScablesSDDpcon3Plast", pcon3plast, plastic);
+ vpcon3plast->SetLineColor(kYellow);
+ vpcon3container->AddNode(vpcon3plast, 0);
+
+ Double_t dr3a = sddCableR4 - pcon3plast->GetRmin(0);
+ TGeoPcon* pcon3Cu = CreateConeConstSection(sddCableR4 - dr3a, sddCableZ4,
+ fgkSDDCableR5 - dr3a, fgkSDDCableZ5,
+ sectionLay3Cu+sectionLay4Cu, 3);
+ TGeoVolume *vpcon3Cu = new TGeoVolume("ITScablesSDDpcon3Cu", pcon3Cu, copper);
+ vpcon3Cu->SetLineColor(kRed);
+ vpcon3container->AddNode(vpcon3Cu, 0);
+
+ //---
+ Double_t dr3b = pcon3Cu->GetRmax(0) - pcon3Cu->GetRmin(0);
+ TGeoPcon* pcon3glass = CreateConeConstSection(sddCableR4-dr3a-dr3b, sddCableZ4,
+ fgkSDDCableR5-dr3a-dr3b, fgkSDDCableZ5,
+ sectionLay3Glass+sectionLay4Glass, 3);
+ TGeoVolume *vpcon3glass = new TGeoVolume("ITScablesSDDpcon3glass", pcon3glass,opticalFiber);
+ vpcon3glass->SetLineColor(kGreen);
+ vpcon3container->AddNode(vpcon3glass, 0);
+
+ moth->AddNode(vpcon3container, 0);
+ moth->AddNode(vpcon3container, 1, rotCableSDD);
+
+
+ //==================================
+ // cables that are grouped at the end of SSD cones
+ //==================================
+
+ Double_t fgkSDDCableR6 = fgkSDDCableR5+10;
+ Double_t fgkSDDCableZ6 = fgkSDDCableZ5+10;
+
+ TGeoVolumeAssembly *endConeSDDCable = new TGeoVolumeAssembly("endConeSDDCable");
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 40, 1*3,2*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 60, 1*3,1*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 85, 2*3,1*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 95, 0*3,1*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 110, 2*3,3*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 146, 0*3,3*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 176, 0*3,1*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 190, 2*3,0*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 220, 1*3,2*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 240, 1*3,2*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 290, 2*3,2*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 315, 1*3,1*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ CreateAndInsetConeCablePart(endConeSDDCable, 350, 1*3,3*4, fgkSDDCableR5,
+ fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
+
+ moth->AddNode(endConeSDDCable, 0, 0);
+
+ TGeoRotation* reflect = new TGeoRotation("reflectEndConeSDDCable");
+ reflect->ReflectZ(kTRUE);
+ moth->AddNode(endConeSDDCable, 1, reflect);
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff