X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySDD.cxx;h=8c79f634f28065ec11a73a0a92aa0c09802b2ea0;hb=ba2089c45cf3a90e180b077e3649477b3c83ddbd;hp=7dfd50b8b1ad38e17717a92d1041c998e99115ec;hpb=fa4639a345a20297281a0898cd8eb58221ed9fb5;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySDD.cxx b/ITS/AliITSv11GeometrySDD.cxx index 7dfd50b8b1a..8c79f634f28 100755 --- a/ITS/AliITSv11GeometrySDD.cxx +++ b/ITS/AliITSv11GeometrySDD.cxx @@ -15,15 +15,22 @@ //************************************************************************* +// // 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 +#include #include // Root Geometry includes @@ -31,24 +38,26 @@ #include #include #include +#include #include +#include #include #include #include +#include +#include -#include "AliITSgeom.h" -#include "AliITSgeomSDD.h" #include "AliITSv11GeometrySDD.h" #include "AliITSv11GeomCableFlat.h" #include "AliITSv11GeomCableRound.h" - -const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName = "ITSsddSensitiv"; -const Double_t AliITSv11GeometrySDD::fgkSegmentLength = 37.2*2*fgkmm; +const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName3 = "ITSsddSensitivL3"; +const char* AliITSv11GeometrySDD::fgSDDsensitiveVolName4 = "ITSsddSensitivL4"; +const Double_t AliITSv11GeometrySDD::fgkSegmentLength = 37.21*2*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLadderWidth = 50.0*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLadderHeight = 30.0*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDW = 3.5*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH = 3.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDW = 7.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH = 7.1*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLadderBeamRadius = 0.6*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLadderLa = 3.*fgkmm; @@ -98,8 +107,8 @@ const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth = 6 *fgkmm; 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 = 129.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 205.*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; @@ -109,8 +118,8 @@ const Int_t AliITSv11GeometrySDD::fgkLay3Ndet = 6; 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 = 220.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 291.*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; @@ -120,6 +129,10 @@ const Int_t AliITSv11GeometrySDD::fgkLay4Ndet = 8; 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 : @@ -146,7 +159,12 @@ const Double_t AliITSv11GeometrySDD::fgkHybFLUpperWidth = 15.012*fgkmm; const Double_t AliITSv11GeometrySDD::fgkHybFLUpperLength = 59.878*fgkmm; const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAlDZ = 11.183*fgkmm; const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAldx = 2.307*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkmu = 1*fgkmicron; // can be increase for checking thin objects + +const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorLen = 10.000*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorWid = 1.490*fgkcm; //??? +const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorAng = 30.0; + +const Double_t AliITSv11GeometrySDD::fgkmu = 1*fgkmicron; // 1*fgkmicron; // can be increase for checking thin objects const Double_t AliITSv11GeometrySDD::fgkHybridThBridgeThick = 0.25*fgkmm; // ??? const Double_t AliITSv11GeometrySDD::fgkHybAlThick = 30*fgkmu; const Double_t AliITSv11GeometrySDD::fgkHybUpThick = 20*fgkmu; @@ -182,7 +200,8 @@ const Double_t AliITSv11GeometrySDD::fgkWaferWidth = 72.5 *fgkmm; 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 @@ -191,8 +210,8 @@ const Double_t AliITSv11GeometrySDD::fgkDigitCablPolyThick = (20+12)*fgkmicron; const Double_t AliITSv11GeometrySDD::fgkWaHVcableAlThick = 30*2./10.*fgkmu; // will probably change // Al ratio is random !!! const Double_t AliITSv11GeometrySDD::fgkWaHVcablePolyThick = 175*fgkmu; // will probably change const Double_t AliITSv11GeometrySDD::fgkWaHVcableLength = 67.08*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkWaHVcableWitdh = 17.4 *fgkmm; // check !!! -const Double_t AliITSv11GeometrySDD::fgkWaHVcableDW = 5.24*fgkmm; // check !!! +const Double_t AliITSv11GeometrySDD::fgkWaHVcableWitdh = 17.4*fgkmm; // check !!! +const Double_t AliITSv11GeometrySDD::fgkWaHVcableDW = 5.24*fgkmm; //5.24*fgkmm;// check !!! const Double_t AliITSv11GeometrySDD::fgkSensorGlassLX = 5. *fgkmm; const Double_t AliITSv11GeometrySDD::fgkSensorGlassLZ = 5. *fgkmm; @@ -207,7 +226,7 @@ const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLZ = 21.3*fgkmm; const Double_t AliITSv11GeometrySDD::fgkTransitHVBondingLZ = 3.6*fgkmm; const Double_t AliITSv11GeometrySDD::fgkTransitHVtailLength = 27*fgkmm; // ???, not yet fixed ... const Double_t AliITSv11GeometrySDD::fgkTransitHVtailWidth = 26*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkTransitHVtailXpos = 8*fgkmm; // ???, a mesurer !!! +const Double_t AliITSv11GeometrySDD::fgkTransitHVtailXpos = 8*fgkmm; //8*fgkmm // ???, a mesurer !!! const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLZ = 10.34*fgkmm; const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLeftZ = 4.11*fgkmm; const Double_t AliITSv11GeometrySDD::fgkTransitHVsideRightZ = 3.5*fgkmm; // ???, a mesurer !!! @@ -216,59 +235,458 @@ const Double_t AliITSv11GeometrySDD::fgkLongHVcablePolyThick= (20+30+125+30+20+3 const Double_t AliITSv11GeometrySDD::fgkLongHVcableAlThick = (30+30*2/10+30)*fgkmu; // check // will probably change const Double_t AliITSv11GeometrySDD::fgkLongHVcableSeparation = 600*fgkmicron; +const Double_t AliITSv11GeometrySDD::fgkRubyDX = 14.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkRubyZladd3 = 250*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkRubyZladd4 = 325*fgkmm; + +// the stesalite ladder foot at its end +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::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::fgkRubyCageHoleY = 6.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkRubyCageAxisShift = 0.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkScrewM4diam = 4.*fgkmm; + +const Double_t AliITSv11GeometrySDD::fgkRubyScrewShiftToCenterY = 0.1; +const Double_t AliITSv11GeometrySDD::fgkRubyHoleDiam = 0.5; + +// 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::fgkEndLadPipeRadius = 5*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; // + +// LV card : +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::fgkHVCardCeramX = 54.01*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCeramY = 40.89*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCeramZ = 0.7*fgkmm; // ??? + +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1X = 6.8*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Z = 1.*fgkmm; // ??? +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Ymid = 4.1*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Yend = 0.95*fgkmm; // doesn't take into account the soldering +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosX = 13.1*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosY = 14.5*fgkmm; + +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2X = 6.8*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Z = 1.*fgkmm; // ??? +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Ymid = 2.9*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Yend = 0.95*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosX = -12.6*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosY = 16.54*fgkmm; + +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xmid = 3.0*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xend = 0.91*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Z = 2.*fgkmm; // ??? +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Y = 3.43*fgkmm; + +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX1 = 14.6*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX2 = 7.2*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX3 = 2.52*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX4 = -4.96*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX5 = -13.82*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY1 = 6.27*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY2 = 0.7*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY3 = 9.1*fgkmm; + +const Double_t AliITSv11GeometrySDD::fgkHVCardCool1X = 14.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Y = 9.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Z = 2.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool2X = 14.25*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Y = 3.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Z = 4.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool3X = 4.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Y = 3.5*fgkmm; +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::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; // ??? +const Double_t AliITSv11GeometrySDD::fgkSectionCoolPolyuEL = 0.4672; +const Double_t AliITSv11GeometrySDD::fgkSectionCoolWaterEL = 0.3496; +const Double_t AliITSv11GeometrySDD::fgkEndLadderEarthCableR = 0.5*fgkmm; +// (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::fgkHybridAlFoilThick = 0.1*fgkmm; // Thickness of Al foil on hybrid side - TO BE CHECKED +const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilWide = 4.2*fgkmm; // Width of Al foil on hybrid side - from digitCableA +const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilSide = 2.0*fgkmm; // Side length of Al foil on hybrid side + +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" + + + + + + ClassImp(AliITSv11GeometrySDD) //________________________________________________________________________ - AliITSv11GeometrySDD::AliITSv11GeometrySDD(): - AliITSv11Geometry(), fMotherVol(0), fAddHybrids(kTRUE), fAddSensors(kTRUE), - fAddHVcables(kTRUE), fAddCables(kTRUE), fAddCoolingSyst(kTRUE), - fCoolingOn(kTRUE), - fAddOnlyLadder3min(-1), fAddOnlyLadder3max(-1), - fAddOnlyLadder4min(-1), fAddOnlyLadder4max(-1) +AliITSv11GeometrySDD::AliITSv11GeometrySDD(): + AliITSv11Geometry(), + fPinSupport(0), + fCoolPipeSupportL(0), + fCoolPipeSupportR(0), + fSDDsensor3(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), + fDigitCableLay4B(0), + fMotherVol(0), + fAddHybrids(kTRUE), + fAddSensors(kTRUE), + fAddHVcables(kTRUE), + fAddCables(kTRUE), + fAddCoolingSyst(kTRUE), + fCoolingOn(kTRUE), + fAddOnlyLadder3min(-1), + fAddOnlyLadder3max(-1), + fAddOnlyLadder4min(-1), + fAddOnlyLadder4max(-1), + fColorCarbonFiber(4), + fColorRyton(5), + fColorPhynox(7), + fColorSilicon(3), + fColorAl(7), + fColorPolyhamide(5), + fColorGlass(2), + fColorSMD(12), + fColorSMDweld(17), + fColorStesalite(20), + fLay3LadderUnderSegDH(0), + fLay4LadderUnderSegDH(0), + fLay3LaddShortRadius(0), + fLay3LaddLongRadius(0), + fLay4LaddShortRadius(0), + fLay4LaddLongRadius(0) { // // Standard constructor // - fDigitCableLay3A = 0; - fDigitCableLay3B = 0; - fDigitCableLay4A = 0; - fDigitCableLay4B = 0; + fCommonVol[0] = NULL; + fCommonVol[1] = NULL; + fCommonTr[0] = NULL; + fCommonTr[1] = NULL; + for (Int_t i=0; iGetMedium(mediumName); + char ch[30]; + snprintf(ch, 30, "ITS_%s",mediumName); + TGeoMedium* medium = gGeoManager->GetMedium(ch); if (! medium) printf("Error(AliITSv11GeometrySDD)::medium %s not found !\n", mediumName); return medium; -}; +} + //________________________________________________________________________ Int_t AliITSv11GeometrySDD::GetLay3NLadders() const{ @@ -385,6 +790,7 @@ Int_t AliITSv11GeometrySDD::GetLay3NLadders() const{ else return (fAddOnlyLadder3max-fAddOnlyLadder3min+1); } + //________________________________________________________________________ Int_t AliITSv11GeometrySDD::GetLay4NLadders() const{ // Get the actual number of ladder in layer 4 @@ -396,6 +802,7 @@ Int_t AliITSv11GeometrySDD::GetLay4NLadders() const{ else return (fAddOnlyLadder4max-fAddOnlyLadder4min+1); } + //________________________________________________________________________ void AliITSv11GeometrySDD::CreateBasicObjects() { // @@ -403,6 +810,7 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { // in Layer3 and Layer4 functions // + fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet]; fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet]; fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet]; @@ -411,13 +819,16 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { fPinSupport = CreatePinSupport(); fCoolPipeSupportL = CreateCoolPipeSupportL(); fCoolPipeSupportR = CreateCoolPipeSupportR(); - fSDDsensor = CreateSDDsensor(); + CreateSDDsensor(); fBaseThermalBridge = CreateBaseThermalBridge(); fHybrid = CreateHybrid(0); - TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J"); - TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2"); - TGeoMedium *alSDD = GetMedium("ITSal"); + TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); //ITSsddCarbonM55J + TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$");//ITSsddKAPTON_POLYCH2 + TGeoMedium *alSDD = GetMedium("AL$"); //ITSal + TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws + TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); + TGeoMedium *raccordMedium = GetMedium("INOX$"); // same as AISI 316-L //******************************************************************** // pieces of the carbon fiber structure @@ -433,11 +844,13 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { Double_t distCenterSideDown = 0.5*fgkLadderWidth/TMath::Cos(beta); //--- the top V of the Carbon Fiber Ladder (segment) - TGeoArb8 *cfLaddTop1 = CreateLadderSide( fgkSegmentLength/2., halfTheta, + TGeoArb8 *cfLaddTop1 = CreateLadderSide( "CFladdTopCornerVol1shape", + fgkSegmentLength/2., halfTheta, -1, fgkLadderLa, fgkLadderHa, fgkLadderl); TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1", cfLaddTop1,carbonFiberLadderStruct); - TGeoArb8 *cfLaddTop2 = CreateLadderSide( fgkSegmentLength/2., halfTheta, + TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerVol2shape", + fgkSegmentLength/2., halfTheta, 1, fgkLadderLa, fgkLadderHa, fgkLadderl); TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerVol2", cfLaddTop2, carbonFiberLadderStruct); @@ -446,11 +859,13 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2-dy, 0); //--- the 2 side V - TGeoArb8 *cfLaddSide1 = CreateLadderSide( fgkSegmentLength/2., beta, -1, + TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerVol1shape", + fgkSegmentLength/2., beta, -1, fgkLadderLb, fgkLadderHb, fgkLadderl); TGeoVolume *cfLaddSideVol1 = new TGeoVolume( "ITSsddCFladdSideCornerVol1", cfLaddSide1,carbonFiberLadderStruct); - TGeoArb8 *cfLaddSide2 = CreateLadderSide( fgkSegmentLength/2., beta, 1, + TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerVol2shape", + fgkSegmentLength/2., beta, 1, fgkLadderLb, fgkLadderHb, fgkLadderl); TGeoVolume *cfLaddSideVol2 = new TGeoVolume( "ITSsddCFladdSideCornerVol2", cfLaddSide2,carbonFiberLadderStruct); @@ -478,41 +893,53 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { sideBeam->SetLineColor(fColorCarbonFiber); //Euler rotation : about Z, then new X, then new Z - TGeoRotation beamRot1("", 90-2.*beta*TMath::RadToDeg(), - -beamPhiPrime*TMath::RadToDeg(),-90); - TGeoRotation beamRot2("", 90-2.*beta*TMath::RadToDeg(), - beamPhiPrime*TMath::RadToDeg(), -90); - TGeoRotation beamRot3("", 90+2.*beta*TMath::RadToDeg(), - beamPhiPrime*TMath::RadToDeg(), -90); - TGeoRotation beamRot4("", 90+2.*beta*TMath::RadToDeg(), - -beamPhiPrime*TMath::RadToDeg(),-90); + TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(), + -beamPhiPrime*TMath::RadToDeg(),-90); + TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(), + beamPhiPrime*TMath::RadToDeg(), -90); + TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(), + beamPhiPrime*TMath::RadToDeg(), -90); + TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(), + -beamPhiPrime*TMath::RadToDeg(),-90); TGeoCombiTrans *beamTransf[8]; beamTransf[0] = new TGeoCombiTrans( 0.5*triangleHeight* TMath::Tan(halfTheta), fgkLadderBeamRadius/2. - dy, - -3*fgkSegmentLength/8, &beamRot1); - beamTransf[1] = new TGeoCombiTrans(*beamTransf[0]); + -3*fgkSegmentLength/8, beamRot1); + + 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]); + -fgkSegmentLength/8, beamRot2); + + 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]); + -3*fgkSegmentLength/8, beamRot3); + + 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* - TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy, -fgkSegmentLength/8,&beamRot4); + TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy, -fgkSegmentLength/8,beamRot4); beamTransf[7] = new TGeoCombiTrans(-0.5*triangleHeight* - TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy,3*fgkSegmentLength/8,&beamRot4); + TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy,3*fgkSegmentLength/8,beamRot4); //--- Beams of the bottom TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius, @@ -532,25 +959,25 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { bottomBeam3, carbonFiberLadderStruct); bottomBeam3Vol->SetLineColor(fColorCarbonFiber); //bottomBeam3Vol->SetLineColor(2); + TGeoRotation *bottomBeamRot1 = new TGeoRotation("", 90, 90, 90); + TGeoRotation *bottomBeamRot2 = new TGeoRotation("",-90, 90, -90); - TGeoRotation bottomBeamRot1("", 90, 90, 90); - TGeoRotation bottomBeamRot2("",-90, 90, -90); TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans - (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,0, &bottomBeamRot1); + (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,0, bottomBeamRot1); TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0, -(fgkLadderHeight/2-fgkLadderBeamRadius)-dy, - -fgkSegmentLength/2, &bottomBeamRot1); + -fgkSegmentLength/2, bottomBeamRot1); TGeoCombiTrans *bottomBeamTransf3 = new TGeoCombiTrans(0, -(fgkLadderHeight/2 - fgkLadderBeamRadius) - - dy, fgkSegmentLength/2, &bottomBeamRot2); + - dy, fgkSegmentLength/2, bottomBeamRot2); // be careful for beams #3: when "reading" from -z to +z and // from the bottom of the ladder, it should draw a Lambda, and not a V - TGeoRotation bottomBeamRot4("", -90, fgkBottomBeamAngle, -90); - TGeoRotation bottomBeamRot5("" ,-90,-fgkBottomBeamAngle, -90); + TGeoRotation *bottomBeamRot4 = new TGeoRotation("", -90, fgkBottomBeamAngle, -90); + TGeoRotation *bottomBeamRot5 = new TGeoRotation("" ,-90,-fgkBottomBeamAngle, -90); TGeoCombiTrans *bottomBeamTransf4 = new TGeoCombiTrans - (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,-fgkSegmentLength/4,&bottomBeamRot4); + (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,-fgkSegmentLength/4,bottomBeamRot4); TGeoCombiTrans *bottomBeamTransf5 = new TGeoCombiTrans - (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,fgkSegmentLength/4, &bottomBeamRot5); + (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,fgkSegmentLength/4, bottomBeamRot5); fLaddSegCommonVol[0] = cfLaddTopVol1; fLaddSegCommonTr[0] = trTop1; fLaddSegCommonVol[1] = cfLaddTopVol2; fLaddSegCommonTr[1] = trTop1; @@ -578,7 +1005,7 @@ void AliITSv11GeometrySDD::CreateBasicObjects() { //******************************************************************** char cableName[30]; for (Int_t i=0; iSetLineColor(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); +} //________________________________________________________________________ @@ -628,27 +1104,34 @@ void AliITSv11GeometrySDD::CheckOverlaps(Double_t precision){ // // a debugging function for checking some possible overlaps // - if (fSDDsensor) fSDDsensor->CheckOverlaps(precision); + if (fSDDsensor3) fSDDsensor3->CheckOverlaps(precision); + if (fSDDsensor4) fSDDsensor4->CheckOverlaps(precision); if (fHybrid) fHybrid->CheckOverlaps(precision); -}; +} //________________________________________________________________________ TGeoCombiTrans *AliITSv11GeometrySDD:: -CreateCombiTrans(const char *name, Double_t dy, Double_t dz, Double_t dphi) { +CreateCombiTrans(const char *name, Double_t dy, Double_t dz, Double_t dphi, + Bool_t planeSym) { // // return the TGeoCombiTrans which make a translation in y and z // and a rotation in phi in the global coord system + // If planeSym = true, the rotation places the object symetrically + // (with respect to the transverse plane) to its position in the + // case planeSym = false // TGeoTranslation t1(dy*CosD(90.+dphi),dy*SinD(90.+dphi), dz); TGeoRotation r1("",0.,0.,dphi); + TGeoRotation r2("",90, 180, -90-dphi); TGeoCombiTrans *combiTrans1 = new TGeoCombiTrans(name); combiTrans1->SetTranslation(t1); - combiTrans1->SetRotation(r1); + if (planeSym) combiTrans1->SetRotation(r1); + else combiTrans1->SetRotation(r2); return combiTrans1; -}; +} //________________________________________________________________________ @@ -660,26 +1143,96 @@ void AliITSv11GeometrySDD::AddTranslationToCombiTrans(TGeoCombiTrans* ct, const Double_t *vect = ct->GetTranslation(); Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz}; ct->SetTranslation(newVect); -}; +} //________________________________________________________________________ void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) { // for code developpment and debugging purposes - if (! fSDDsensor) CreateBasicObjects(); + if (! fSDDsensor3) CreateBasicObjects(); + + // moth->AddNode(fPinSupport, 1, 0); + // moth->AddNode(fCoolPipeSupportL, 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); + + TGeoVolume* seg = CreateLadderSegment( 3, 0); + moth->AddNode(seg, 1, 0); + +// TGeoVolumeAssembly *lay3Ladder = CreateLadder(3); +// moth->AddNode(lay3Ladder, 1, 0); -// moth->AddNode(fPinSupport, 1, 0); -// moth->AddNode(fCoolPipeSupportL, 1, 0); -// moth->AddNode(fBaseThermalBridge, 1, 0); -// moth->AddNode(fHybrid,100,0); - moth->AddNode(fSDDsensor, 1, 0); +// TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3); +// moth->AddNode(lay3Detectors, 1, 0); +// TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3); +// moth->AddNode(lay3Detectors, 1, 0); -// TGeoVolume* seg = CreateLadderSegment( 3, 0); -// moth->AddNode(seg, 1, 0); -}; +// 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); + + + + /* + //================================== + //--- 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); + */ +} //________________________________________________________________________ @@ -694,13 +1247,19 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) { return; }; - TGeoMedium *airSDD = GetMedium("ITSair"); + TGeoMedium *airSDD = GetMedium("SDD AIR$"); fMotherVol = moth; - if (! fSDDsensor) CreateBasicObjects(); + if (! fSDDsensor3) CreateBasicObjects(); - TGeoVolume *lay3Ladder = CreateLadder(3); - TGeoVolume *lay3Detectors = CreateDetectors(3); + //==================================== + // First we create the central barrel + //==================================== + + TGeoVolumeAssembly *lay3Ladder = CreateLadder(3); + TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3); + TGeoVolumeAssembly *lay3Ladd2Det = CreateDetectorsAssemblyLadd2(); + //TGeoVolume *lay3Detectors = CreateDetectors(3); TGeoTube *virtualLayer3Shape = new TGeoTube("ITSsddLayer3Shape", fgkLay3Rmin,fgkLay3Rmax,fgkLay3Length*0.5); TGeoVolume *virtualLayer3 = new TGeoVolume("ITSsddLayer3", @@ -720,30 +1279,257 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) { for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) { - sprintf(rotName, "ITSsddLay3Ladd%i",iLadd); + Double_t ladderPhi = -3*dPhi+iLadd*dPhi; + snprintf(rotName, 30, "ITSsddLay3Ladd%i",iLadd); Double_t minRadiusLadBox = fLay3LaddShortRadius-fLay3LadderUnderSegDH; if (iLadd%2 != 0) minRadiusLadBox = fLay3LaddLongRadius-fLay3LadderUnderSegDH; minRadiusLadBox += ((TGeoBBox*)lay3Ladder->GetShape())->GetDY(); - TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName,minRadiusLadBox, - 0,-90+iLadd*dPhi); + 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); + snprintf(rotName, 30, "ITSsddLay3DetBox%i",iLadd); Double_t minRadiusDetBox = fgkLay3DetShortRadius; if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius; minRadiusDetBox += detectorsThick/2; - TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox, - 0,-90+iLadd*dPhi); - virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet); + TGeoCombiTrans *ctDet; + ctDet = CreateCombiTrans(rotName, minRadiusDetBox, + 0, ladderPhi, kTRUE); + + if (iLadd != 2) + virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet); + else + virtualLayer3->AddNode(lay3Ladd2Det , iLadd, ctDet); + /////////////////////////////////////////////////// } - if(GetDebug(1)) virtualLayer3->CheckOverlaps(0.01); + /* + //==================================== + // Then the forward rapidity pieces + // (cooling, Carlos, LV, HV ...) + //==================================== + + 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)) { + virtualLayer3->CheckOverlaps(0.01); + //virtualForward3Pos->CheckOverlaps(0.01); + //virtualForward3Neg->CheckOverlaps(0.01); + } + virtualLayer3->SetVisibility(kFALSE); + //virtualForward3Pos->SetVisibility(kFALSE); + //virtualForward3Neg->SetVisibility(kFALSE); + + moth->AddNode(virtualLayer3, 1, 0); -}; + //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)&&(fAddOnlyLadder3maxDefineSection(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)&&(fAddOnlyLadder3maxAddNode(lay3EndLadder, iLadd*2, ctEndLaddPos); + virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg); + } + + if(GetDebug(1)) { + virtualForward3Pos->CheckOverlaps(0.01); + virtualForward3Neg->CheckOverlaps(0.01); + } + + // 180deg Y rotation to compensate the cancellation of ITSD volume + // (idortm[199] in AliITSv11Hybrid : z---> -z; x ---> -x; y ---> y) + TGeoRotation *y180 = new TGeoRotation(); + y180->SetAngles( 90.,180., 90., 90.,180., 0.); + moth->AddNode(virtualForward3Pos, 1, y180); + moth->AddNode(virtualForward3Neg, 1, y180); +} //________________________________________________________________________ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { @@ -759,20 +1545,28 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { fMotherVol = moth; - if (! fSDDsensor) CreateBasicObjects(); + if (! fSDDsensor3) CreateBasicObjects(); TGeoTube *virtualLayer4Shape =new TGeoTube("ITSsddLayer4Shape", fgkLay4Rmin,fgkLay4Rmax,fgkLay4Length*0.5); - TGeoMedium *airSDD = GetMedium("ITSair"); + TGeoMedium *airSDD = GetMedium("SDD AIR$"); TGeoVolume *virtualLayer4 = new TGeoVolume("ITSsddLayer4", virtualLayer4Shape, airSDD); - TGeoVolume *lay4Ladder = CreateLadder(4); - TGeoVolume *lay4Detectors = CreateDetectors(4); + + //==================================== + // First we create the central barrel + //==================================== + + TGeoVolumeAssembly *lay4Ladder = CreateLadder(4); + //TGeoVolume *lay4Detectors = CreateDetectors(4); + TGeoVolumeAssembly *lay4Detectors = CreateDetectorsAssembly(4); + Double_t dPhi = 360./fgkLay4Nladd; Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness; + // placing virtual ladder and detectors volumes following ladder // ordering convention - char rotName[20]; + char rotName[30]; Int_t iLaddMin = 0; Int_t iLaddMax = fgkLay4Nladd; if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) { @@ -780,34 +1574,222 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { iLaddMax = fAddOnlyLadder4max+1; } for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) { - sprintf(rotName, "ITSsddLay4Ladd%i",iLadd); + + Double_t ladderPhi = -5*dPhi + iLadd*dPhi; + snprintf(rotName, 30, "ITSsddLay4Ladd%i",iLadd); Double_t minRadiusLadBox = fLay4LaddShortRadius-fLay4LadderUnderSegDH; if (iLadd%2 != 0) minRadiusLadBox = fLay4LaddLongRadius-fLay4LadderUnderSegDH; minRadiusLadBox += ((TGeoBBox*)lay4Ladder->GetShape())->GetDY(); TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName, minRadiusLadBox, - 0, -90+iLadd*dPhi); + 0, ladderPhi, kTRUE); virtualLayer4->AddNode(lay4Ladder, iLadd, ctLadd); - sprintf(rotName, "ITSsddLay4DetBox%i",iLadd); + /////////////////////////////////////////////////// + snprintf(rotName, 30, "ITSsddLay4DetBox%i",iLadd); Double_t minRadiusDetBox = fgkLay4DetShortRadius; if (iLadd%2 != 0) minRadiusDetBox = fgkLay4DetLongRadius; minRadiusDetBox += detBoxThickness/2; TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox, - 0, -90+iLadd*dPhi); + 0, ladderPhi, kTRUE); virtualLayer4->AddNode(lay4Detectors, iLadd, ctDet); + /////////////////////////////////////////////////// + } + + /* + //==================================== + // Then the pieces at forward rapidity + // (cooling, Carlos, LV, HV ...) + //==================================== + + 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); } + */ if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01); + virtualLayer4->SetVisibility(kFALSE); + //virtualForward4Pos->SetVisibility(kFALSE); + //virtualForward4Neg->SetVisibility(kFALSE); + moth->AddNode(virtualLayer4,1,0); -}; + //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; + + snprintf(rotName, 30, "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); + } + + // 180deg Y rotation to compensate the cancellation of ITSD volume + // (idortm[199] in AliITSv11Hybrid : z---> -z; x ---> -x; y ---> y) + TGeoRotation *y180 = new TGeoRotation(); + y180->SetAngles( 90.,180., 90., 90.,180., 0.); + moth->AddNode(virtualForward4Pos, 1, y180); + moth->AddNode(virtualForward4Neg, 1, y180); +} //________________________________________________________________________ -TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { +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; @@ -830,11 +1812,7 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { printf("AliITSv11GeometrySDD::CreateLadder : error=wrong layer\n"); }; Double_t ladderBoxDH = fgkLadderHeight+fgkLadderSegBoxDH+underSegDH; - TGeoBBox *ladBox = new TGeoBBox("ITSsddLadBox", - fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW, - ladderBoxDH/2, ladderLength/2); - TGeoMedium *airSDD = GetMedium("ITSair"); - TGeoVolume *virtualLadder = new TGeoVolume("ITSsddLadder",ladBox, airSDD); + TGeoVolumeAssembly *virtualLadder = new TGeoVolumeAssembly("ITSsddLadder"); // placing virtual ladder segment following detector ordering convention //======================================================================= @@ -843,8 +1821,9 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { // 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); TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment); - sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment); + snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment); Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment) + fgkSegmentLength/2; TGeoTranslation *segTr = new TGeoTranslation(transName, 0, @@ -855,7 +1834,8 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) { TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment); - sprintf(transName, "ITSsddLay%iLaddSeg%i", iLay, iSegment); + //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment); + snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment); Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment) + fgkSegmentLength/2; TGeoTranslation *segTr = new TGeoTranslation(transName, 0, @@ -866,7 +1846,7 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { // putting virtual volume corresponding to the end of ladder //======================================================================= - TGeoVolume *endLadder = CreateEndLadder( iLay ); + TGeoVolumeAssembly *endLadder = CreateEndLadder( iLay ); Double_t endLength = (ladderLength - nDetectors*fgkSegmentLength)/2.; TGeoTranslation *endTrZPos = new TGeoTranslation("ITSsddEndTrZPos",0,0, fgkSegmentLength*(nDetectors/2)+endLength/2.); @@ -888,27 +1868,34 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { for (Int_t iPt=1; iPt1) 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; iPt1) rotation = fgkHybridAngle-90; - digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation); + if (iPt>1) { + rotation = fgkHybridAngle-90; + digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation); + } else + digitCableB[iSegment].CreateAndInsertCableSegment(iPt); }; }; // HV cable //======================================================================= if (fAddHVcables) { - TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2"); - TGeoMedium *alSDD = GetMedium("ITSal"); + TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddKAPTON_POLYCH2 + TGeoMedium *alSDD = GetMedium("AL$"); //ITSal AliITSv11GeomCableFlat cableHV[fgkLay4Ndet]; // temp !!! char cableHVname[30]; for (Int_t iSegment = 0; 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]; @@ -935,11 +1924,13 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { 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; @@ -950,7 +1941,7 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { 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]; @@ -958,39 +1949,49 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { 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); }; }; //********************************** if(GetDebug(1)) virtualLadder->CheckOverlaps(0.01); - virtualLadder->SetVisibility(kFALSE); return virtualLadder; -}; +} //________________________________________________________________________ -TGeoArb8 *AliITSv11GeometrySDD::CreateLadderSide(Double_t dz, Double_t angle, - Double_t xSign, Double_t L, Double_t H, Double_t l) { +TGeoArb8 *AliITSv11GeometrySDD::CreateLadderSide(const char *name, + Double_t dz, Double_t angle, Double_t xSign, + Double_t L, Double_t H, Double_t l) { // Create one half of the V shape corner of CF ladder TGeoArb8 *cfLaddSide = new TGeoArb8(dz); - cfLaddSide->SetVertex( 0, 0, 0); - cfLaddSide->SetVertex( 1, 0, -H); - cfLaddSide->SetVertex( 2, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)), - -L*TMath::Cos(angle)-l*TMath::Sin(angle)); - cfLaddSide->SetVertex( 3, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); - cfLaddSide->SetVertex( 4, 0, 0); - cfLaddSide->SetVertex( 5, 0, -H); - cfLaddSide->SetVertex( 6, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)), - -L*TMath::Cos(angle)-l*TMath::Sin(angle)); - cfLaddSide->SetVertex(7, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); + cfLaddSide->SetName(name); + + // Points must be in clockwise order + cfLaddSide->SetVertex(0, 0, 0); + cfLaddSide->SetVertex(2, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)), + -L*TMath::Cos(angle)-l*TMath::Sin(angle)); + cfLaddSide->SetVertex(4, 0, 0); + cfLaddSide->SetVertex(6, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)), + -L*TMath::Cos(angle)-l*TMath::Sin(angle)); + if (xSign < 0) { + cfLaddSide->SetVertex(1, 0, -H); + cfLaddSide->SetVertex(3, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); + cfLaddSide->SetVertex(5, 0, -H); + cfLaddSide->SetVertex(7, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); + } else { + cfLaddSide->SetVertex(1, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); + cfLaddSide->SetVertex(3, 0, -H); + cfLaddSide->SetVertex(5, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle)); + cfLaddSide->SetVertex(7, 0, -H); + } return cfLaddSide; -}; +} //________________________________________________________________________ @@ -1016,21 +2017,40 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { Double_t flUpThick = fgkHybGlueUpThick+fgkHybUpThick; //**************************************************** media : - TGeoMedium *airSDD = GetMedium("ITSair"); - TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J"); - TGeoMedium *alSDD = GetMedium("ITSal"); - TGeoMedium *alSDD80p100 = GetMedium("ITSal"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *alSDD50p100 = GetMedium("ITSal"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2"); - TGeoMedium *niSDD = GetMedium("COPPER"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *glueAG = GetMedium("ITSsddKAPTON_POLYCH2"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *siliconSDD = GetMedium("ITSsddSiChip"); - TGeoMedium *medSMD = GetMedium("SDDX7Rcapacitors"); // TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *medSMDweld = GetMedium("SDDX7Rcapacitors"); // TO CODE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *airSDD = GetMedium("SDD AIR$"); + TGeoMedium *carbonFiberLadderStruct = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddCarbonM55J + TGeoMedium *alSDD = GetMedium("AL$"); //ITSal + TGeoMedium *alSDD80p100 = GetMedium("AL$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *alSDD50p100 = GetMedium("AL$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddKAPTON_POLYCH2 + TGeoMedium *niSDD = GetMedium("NICKEL$"); + TGeoMedium *glueAG = GetMedium("SDDKAPTON (POLYCH2)$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *siliconSDD = GetMedium("SDD SI CHIP$"); //ITSsddSiChip + TGeoMedium *medSMD = GetMedium("SDD X7R capacitors$"); // SDDX7Rcapacitors + TGeoMedium *medSMDweld = GetMedium("SDD X7R weld$"); //**************************************************** main volume : - TGeoBBox *hybridBox = new TGeoBBox("",fgkHybridWidth/2, volumeThick/2, - (fgkHybridLength)/2); +// TGeoBBox *hybridBox = new TGeoBBox("",fgkHybridWidth/2, volumeThick/2, +// (fgkHybridLength)/2); + Double_t xhybr[6],yhybr[6]; + xhybr[0] = -fgkHybridWidth/2; + yhybr[0] = -volumeThick/2; + xhybr[1] = fgkHybridWidth/2; + yhybr[1] = -volumeThick/2; + xhybr[2] = fgkHybridWidth/2; + yhybr[2] = volumeThick/2; + xhybr[3] = -fgkHybridWidth/2; + yhybr[3] = volumeThick/2; + xhybr[4] = xhybr[3] - 1.05*fgkHybCC2SensorLen*SinD(fgkHybCC2SensorAng); + yhybr[4] = yhybr[3] - 1.05*fgkHybCC2SensorLen*CosD(fgkHybCC2SensorAng); + xhybr[5] = xhybr[4]; + yhybr[5] = yhybr[4] - volumeThick; + + TGeoXtru *hybridBox = new TGeoXtru(2); + hybridBox->DefinePolygon(6, xhybr, yhybr); + hybridBox->DefineSection(0,-fgkHybridLength/2); + hybridBox->DefineSection(1, fgkHybridLength/2); + TGeoVolume *hybrid = new TGeoVolume("ITSsddHybridVol", hybridBox, airSDD); @@ -1071,16 +2091,18 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { TGeoTranslation hybHolePos2Tr(roundHoleX, -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2, fgkHybridLength/2-fgkHybRndHoleZ); - TGeoRotation rotHole("", 0, 90, 0); - TGeoCombiTrans *hybHolePos1 = new TGeoCombiTrans(hybHolePos1Tr, rotHole); + + TGeoRotation *rotHole = new TGeoRotation("", 0, 90, 0); + TGeoCombiTrans *hybHolePos1 = new TGeoCombiTrans(hybHolePos1Tr, *rotHole); hybHolePos1->SetName("hybHolePos1"); - TGeoCombiTrans *hybHolePos2 = new TGeoCombiTrans(hybHolePos2Tr, rotHole); + TGeoCombiTrans *hybHolePos2 = new TGeoCombiTrans(hybHolePos2Tr, *rotHole); hybHolePos2->SetName("hybHolePos2"); upGlueScreenTr->RegisterYourself(); alScreenTr->RegisterYourself(); hybHolePos1->RegisterYourself(); hybHolePos2->RegisterYourself(); + delete rotHole; TGeoCompositeShape *sScreenAl = new TGeoCompositeShape( "sAlScreenLayer:AlScreenTr-(sRoundHole:hybHolePos1" @@ -1138,7 +2160,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { TGeoBBox *sAlBar2 = new TGeoBBox("sAlBar2", fgkHybridWidth/2, fgkHybAlThick/2, sideWidth2/2); - TGeoTranslation *upGlueBarTr2 = new TGeoTranslation("upGlueBarTr2", 0, + TGeoTranslation *upGlueBarTr2 = new TGeoTranslation("upGlueBarTr2", 0, lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2, (fgkHybridLength-sideWidth2)/2); TGeoTranslation *alBarTr2 = new TGeoTranslation("alBarTr2", 0, @@ -1160,7 +2182,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { hybrid->AddNode(vLowUpGlueBar2, 1, 0); hybrid->AddNode(vLowAlBar2, 1, 0); - if(GetDebug(3)){ // Remove compiler warning. + if(GetDebug(3)) { // Remove compiler warning. sAlScreenLayer->InspectShape(); sUpGlueScreenLayer->InspectShape(); sRoundHole->InspectShape(); @@ -1188,7 +2210,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ ); lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ ); lowFLpiece.SetInitialNode(hybrid); - lowFLpiece.CreateAndInsertCableSegment(1); + lowFLpiece.CreateAndInsertBoxCableSegment(1); lowFLpiece.ResetPoints(); Double_t piece2width = fgkHybFLlowAmbX-fgkHybFLlowPasX @@ -1200,7 +2222,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x2[0] = x1[0]; lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ ); lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ ); - lowFLpiece.CreateAndInsertCableSegment(1); + lowFLpiece.CreateAndInsertBoxCableSegment(1); lowFLpiece.ResetPoints(); Double_t piece3width = fgkHybridWidth - fgkHybFLlowAmbX @@ -1212,14 +2234,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x2[0] = x1[0]; lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ ); lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ ); - lowFLpiece.CreateAndInsertCableSegment(1); + lowFLpiece.CreateAndInsertBoxCableSegment(1); Double_t zChips[4] = {fgkHybFLlowChipZ1,fgkHybFLlowChipZ2, fgkHybFLlowChipZ3,fgkHybFLlowChipZ4}; Double_t vX[3] = {1,0,0}; for (Int_t i=0; i<3; i++) { char ch[20]; - sprintf(ch, "lowFLpieceA%i", i+4); + snprintf(ch, 20, "lowFLpieceA%i", i+4); lowFLpiece.SetName(ch); lowFLpiece.SetWidth(zChips[i+1]-zChips[i]-fgkHybFLlowHoleDZ); @@ -1230,16 +2252,16 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x1[2] = zPiece; x2[2] = zPiece; lowFLpiece.AddCheckPoint( hybrid, 0, x2, vX ); lowFLpiece.AddCheckPoint( hybrid, 1, x1, vX ); - lowFLpiece.CreateAndInsertCableSegment(1,90); + lowFLpiece.CreateAndInsertBoxCableSegment(1,90); lowFLpiece.ResetPoints(); - sprintf(ch, "lowFLpieceB%i", i+4); + snprintf(ch, 20, "lowFLpieceB%i", i+4); lowFLpiece.SetName(ch); x1[0] = fgkHybridWidth/2 - piece3width; x2[0] = x1[0] - fgkHybFLlowHoleAmbDX; lowFLpiece.AddCheckPoint( hybrid, 0, x1, vX ); lowFLpiece.AddCheckPoint( hybrid, 1, x2, vX ); - lowFLpiece.CreateAndInsertCableSegment(1,90); + lowFLpiece.CreateAndInsertBoxCableSegment(1,90); }; //**************************************************** chips+CC: @@ -1260,7 +2282,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { char ch[20]; for (Int_t i=0; i<4; i++) { - sprintf(ch, "pascalCC%i", i); + snprintf(ch, 20, "pascalCC%i", i); chip.SetName(ch); x1[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2; x2[0] = x1[0] + fgkHybPascalDX; @@ -1268,24 +2290,23 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x2[2] = x1[2]; chip.AddCheckPoint( hybrid, 0, x1, vX ); chip.AddCheckPoint( hybrid, 1, x2, vX ); - chip.CreateAndInsertCableSegment(1,-90); + chip.CreateAndInsertBoxCableSegment(1,-90); chip.ResetPoints(); - sprintf(ch, "ambraCC%i", i); + snprintf(ch, 20, "ambraCC%i", i); chip.SetName(ch); x1[0] = fgkHybFLlowAmbX - fgkHybridWidth/2 - fgkHybAmbraDX/2; x2[0] = x1[0] + fgkHybAmbraDX; chip.AddCheckPoint( hybrid, 0, x1, vX ); chip.AddCheckPoint( hybrid, 1, x2, vX ); - chip.CreateAndInsertCableSegment(1,-90); + chip.CreateAndInsertBoxCableSegment(1,-90); chip.ResetPoints(); }; //**************************************************** 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); + snprintf(ch, 20, "ccLayerA%i", i); AliITSv11GeomCableFlat ccLayer1(ch, 6.6*fgkmm, ccUpLayerTotThick); ccLayer1.SetInitialNode(hybrid); @@ -1303,9 +2324,9 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x2[2] = x1[2]; ccLayer1.AddCheckPoint( hybrid, 0, x1, vX ); ccLayer1.AddCheckPoint( hybrid, 1, x2, vX ); - ccLayer1.CreateAndInsertCableSegment(1,-90); + ccLayer1.CreateAndInsertBoxCableSegment(1,-90); - sprintf(ch, "ccLayerB%i", i); + snprintf(ch, 20, "ccLayerB%i", i); AliITSv11GeomCableFlat ccLayer2(ch, fgkHybChipsDZ, ccUpLayerTotThick); ccLayer2.SetInitialNode(hybrid); ccLayer2.SetNLayers(2); @@ -1317,9 +2338,9 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { x2[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX - fgkHybAmbraDX/2; ccLayer2.AddCheckPoint( hybrid, 0, x1, vX ); ccLayer2.AddCheckPoint( hybrid, 1, x2, vX ); - ccLayer2.CreateAndInsertCableSegment(1,-90); + ccLayer2.CreateAndInsertBoxCableSegment(1,-90); ccLayer2.ResetPoints(); - sprintf(ch, "ccLayerC%i", i); + snprintf(ch, 20, "ccLayerC%i", i); ccLayer2.SetName(ch); x1[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX + fgkHybAmbraDX/2; x2[0] = fgkHybridWidth/2 - fgkHybFLUpperWidth + 3*fgkmm; @@ -1329,7 +2350,53 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { ccLayer2.AddCheckPoint( hybrid, 0, x1, vX ); ccLayer2.AddCheckPoint( hybrid, 1, x2, vX ); - ccLayer2.CreateAndInsertCableSegment(1,-90); + ccLayer2.CreateAndInsertBoxCableSegment(1,-90); + + //**************************************************** CC to sensors: + // (alas, we cannot use GeomCableFlat here because section is not constant) + Double_t xcc[8],ycc[8]; + xcc[0] = -0.5*ccLayer1.GetWidth(); + ycc[0] = 0; + xcc[1] = 0.5*ccLayer1.GetWidth(); + ycc[1] = 0; + xcc[2] = xcc[1]; + ycc[2] = -fgkHybCC2SensorLen*0.8; + xcc[3] = xcc[2] + 0.1*fgkHybCC2SensorWid; + ycc[3] = ycc[2]; + xcc[4] = xcc[3]; + ycc[4] = -fgkHybCC2SensorLen; + xcc[5] = xcc[4] - fgkHybCC2SensorWid; + ycc[5] = ycc[4]; + xcc[6] = xcc[5]; + ycc[6] = 0.8*ycc[5]; + xcc[7] = xcc[0]; + ycc[7] = 0.2*ycc[5]; + + TGeoXtru* ccToSensPoliSh = new TGeoXtru(2); + ccToSensPoliSh->DefinePolygon(8, xcc, ycc); + ccToSensPoliSh->DefineSection(0, 0.); + ccToSensPoliSh->DefineSection(1, ccLayer1.GetThickness()); + + snprintf(ch, 20, "ccToSens%i", i); + TGeoVolume* ccToSensPoliVol = new TGeoVolume(ch, ccToSensPoliSh, polyhamideSDD); + ccToSensPoliVol->SetLineColor(fColorPolyhamide); + + TGeoXtru* ccToSensAlSh = new TGeoXtru(2); + ccToSensAlSh->DefinePolygon(8, xcc, ycc); + ccToSensAlSh->DefineSection(0, 0.); + ccToSensAlSh->DefineSection(1, fgkHybAlCCThick); + + snprintf(ch, 20, "ccToSensAl%i", i); + TGeoVolume* ccToSensAlVol = new TGeoVolume(ch, ccToSensAlSh, alSDD50p100); + ccToSensAlVol->SetLineColor(fColorAl); + + ccToSensPoliVol->AddNode(ccToSensAlVol, 1, 0); + + Double_t coord[3]; + ccLayer1.GetPoint(0,coord); + hybrid->AddNode(ccToSensPoliVol, i+1, + new TGeoCombiTrans(coord[0], coord[1], coord[2], + new TGeoRotation("",-90-fgkHybCC2SensorAng, 90, 90))); }; //**************************************************** FL UP: @@ -1359,12 +2426,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { // Al at ~50% vAluStrip->SetLineColor(fColorAl); - TGeoRotation rotAluStrip("rotAluStrip",0, -90, 90); + //TGeoRotation rotAluStrip("rotAluStrip",0, -90, 90); + TGeoRotation *rotAluStrip = new TGeoRotation("rotAluStrip",0, -90, 90); + Double_t yRotAluStrip = lowLayerYmin+lowFLTotalThick +flUpThick+fgkHybAlThick/2; TGeoCombiTrans *aluStripTr1 = new TGeoCombiTrans( fgkHybridWidth/2,yRotAluStrip, - fgkHybridLength/2-fgkHybFLlowChipZ1+1*fgkmm, &rotAluStrip); + fgkHybridLength/2-fgkHybFLlowChipZ1+1*fgkmm, rotAluStrip); TGeoCombiTrans *aluStripTr2 = new TGeoCombiTrans(*aluStripTr1); AddTranslationToCombiTrans(aluStripTr2,0,0, fgkHybFLlowChipZ1-fgkHybFLlowChipZ2); @@ -1379,7 +2448,6 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { hybrid->AddNode(vAluStrip, 2, aluStripTr2); hybrid->AddNode(vAluStrip, 3, aluStripTr3); hybrid->AddNode(vAluStrip, 4, aluStripTr4); - //**************************************************** SMD: TGeoBBox *hybSMD = new TGeoBBox("ITSsddSMDshape", fgkHybSMDmiddleL/2+fgkHybSMDendL, @@ -1412,25 +2480,24 @@ TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) { hybrid->AddNode(vHybSMD, i+1, vHybSMDtr); }; - if (iLRSide == 0) { }; if(GetDebug(1)) hybrid->CheckOverlaps(0.01); hybrid->SetVisibility(kFALSE); return hybrid; -}; - +} //________________________________________________________________________ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { // - // Return a box volume containing a segment of a ladder. + // Return a TGeoVolume* containing a segment of a ladder. // - TGeoMedium *airSDD = GetMedium("ITSair"); - TGeoMedium *phynoxSDD = GetMedium("ITSal"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *coolerMediumSDD = GetMedium("WATER"); + TGeoMedium *phynoxSDD = GetMedium("INOX$"); + TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); + TGeoMedium *airSDD = GetMedium("SDD AIR$"); + TGeoMedium *alSDD = GetMedium("AL$"); Double_t tDY = fgkLadderSegBoxDH/2; //space left on top of the ladder Double_t segmentLength = fgkSegmentLength; @@ -1488,13 +2555,46 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { //**************************** // The segment volume //**************************** - TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox", - fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW, - fgkLadderHeight/2+fgkLadderSegBoxDH/2, - segmentLength/2); - + + // 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); + // A shaped Xtru instead of a simple BBox to avoid overlaps and extrusions + TGeoXtru *segBox = new TGeoXtru(2); + segBox->SetName("ITSsddSegBox"); + + Double_t xseg[12],yseg[12]; + xseg[ 0] = -(fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW); + yseg[ 0] = fgkLadderHeight/2+fgkLadderSegBoxDH/2; + xseg[ 1] = xseg[0]; + yseg[ 1] = -yseg[0]; + xseg[ 2] = 0.87*xseg[1]; + yseg[ 2] = yseg[1]; + xseg[ 3] = 0.82*xseg[1]; + yseg[ 3] = -yseg[0] - 0.82*fgkHybCC2SensorLen; + xseg[ 4] = 0.78*xseg[1]; + yseg[ 4] = yseg[3]; + xseg[ 5] = 0.83*xseg[1]; + yseg[ 5] = yseg[1]; + + for (Int_t j=0; j<6; j++) { + xseg[6+j] = -xseg[5-j]; + yseg[6+j] = yseg[5-j]; + } + + segBox->DefinePolygon(12, xseg, yseg); + segBox->DefineSection(0,-segmentLength/2); + segBox->DefineSection(1, segmentLength/2); + TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment", segBox, airSDD); + virtualSeg->SetVisibility(kFALSE); //****************************** // Carbon fiber structure : @@ -1514,29 +2614,56 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { //********************************** // Pine support of the sensors : //********************************** - TGeoRotation rotPS1("",0,-90,90); - TGeoRotation rotPS2("",0,-90,-90); + 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); + sensorCenterZPos+fgkPinDXminOnSensor,rotPS1); + + 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); + sensorCenterZPos+fgkPinDXminOnSensor,rotPS2); + + 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); @@ -1546,33 +2673,77 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { 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; - + + TGeoMedium *pinMed = GetMedium("RYTON$"); + 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("", -halfTheta*TMath::RadToDeg(), -90, 90); - TGeoRotation rotCPS1("", halfTheta*TMath::RadToDeg(), -90, -90); + TGeoRotation *rotCPS2 = new TGeoRotation("", -halfTheta*TMath::RadToDeg(), -90, 90); + TGeoRotation *rotCPS1 = new TGeoRotation("", halfTheta*TMath::RadToDeg(), -90, -90); TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL, -fgkLadderHeight/2. - tDY +coolPipeSuppH+fgkLadderBeamRadius, - -segmentLength/2., &rotCPS1); - TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(*transCPS1); + -segmentLength/2., rotCPS1); + + 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); + segmentLength/2., rotCPS2); + + TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL, + -fgkLadderHeight/2.- tDY + +coolPipeSuppH+fgkLadderBeamRadius, + segmentLength/2., rotCPS2); AddTranslationToCombiTrans(transCPS4, 0, 0, -segmentLength); virtualSeg->AddNode(fCoolPipeSupportL, 1, transCPS1); @@ -1592,25 +2763,25 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { fgkLadderBeamRadius+coolPipeSuppH, 0); if (fAddCoolingSyst) { - TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2, - fgkCoolPipeOuterDiam/2, - segmentLength/2); - TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2, - segmentLength/2); - - TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipe", - coolingPipeShape, phynoxSDD ); - coolingPipe->SetLineColor(fColorPhynox); - TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingLiquid",coolerShape, - coolerMediumSDD ); - - - virtualSeg->AddNode(coolingPipe, 1, pipeTr1); - virtualSeg->AddNode(coolingPipe, 2, pipeTr2); - if (fCoolingOn) { - virtualSeg->AddNode(cooler, 1, pipeTr1); - virtualSeg->AddNode(cooler, 2, pipeTr2); - }; + TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2, + fgkCoolPipeOuterDiam/2, + segmentLength/2); + TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2, + segmentLength/2); + + TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipe", + coolingPipeShape, phynoxSDD ); + coolingPipe->SetLineColor(fColorPhynox); + TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingLiquid",coolerShape, + coolerMediumSDD ); + + + virtualSeg->AddNode(coolingPipe, 1, pipeTr1); + virtualSeg->AddNode(coolingPipe, 2, pipeTr2); + if (fCoolingOn) { + virtualSeg->AddNode(cooler, 1, pipeTr1); + virtualSeg->AddNode(cooler, 2, pipeTr2); + }; }; //********************************** @@ -1631,7 +2802,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { //************************* // the 2 hybrids : //************************* - Double_t hybDy = ((TGeoBBox*)fHybrid->GetShape())->GetDY(); + Double_t hybDy = ((TGeoXtru*)fHybrid->GetShape())->GetY(2); Double_t distAxeToHybridCenter = fgkBTBaxisAtoBase+hybDy; Double_t hybrVolX = ( distAxeToHybridCenter*CosD(fgkHybridAngle) @@ -1655,8 +2826,8 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { //*********** if (fAddCables) { // Starting from this segment - Double_t hybDz = ((TGeoBBox*)fHybrid->GetShape())->GetDZ(); - Double_t hybDx = ((TGeoBBox*)fHybrid->GetShape())->GetDX(); + Double_t hybDz = ((TGeoXtru*)fHybrid->GetShape())->GetZ(1); + Double_t hybDx = ((TGeoXtru*)fHybrid->GetShape())->GetX(1); Double_t posDigitCableAlongHyb = shiftHyb+ hybDx - digitCableA->GetWidth()/2; Double_t distAxeToDigitCableCenter = distAxeToHybridCenter+hybDy @@ -1701,28 +2872,71 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { digitCableB[iCable].GetPoint( 1, coord); digitCableB[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ); }; + + // Now the small Al foil on the same hybrid side + Double_t xfoil[5],yfoil[5]; + hybDx *= 0.95; + xfoil[0] = -fgkHybridAlFoilWide/2; + yfoil[0] = hybDx; + xfoil[1] = fgkHybridAlFoilWide/2; + yfoil[1] = yfoil[0]; + xfoil[2] = xfoil[1]; + yfoil[2] = -hybDx + (fgkHybridAlFoilWide - fgkHybridAlFoilSide); + xfoil[3] = xfoil[0] + fgkHybridAlFoilSide; + yfoil[3] = -hybDx; + xfoil[4] = xfoil[0]; + yfoil[4] = yfoil[3]; + + TGeoXtru* alFoilSh = new TGeoXtru(2); + alFoilSh->DefinePolygon(5, xfoil, yfoil); + alFoilSh->DefineSection(0,-fgkHybridAlFoilThick/2); + alFoilSh->DefineSection(1, fgkHybridAlFoilThick/2); + + TGeoVolume* alFoilVol = new TGeoVolume("ITSsddAlFoilHybSide", alFoilSh, alSDD); + alFoilVol->SetLineColor(fColorAl); + + Double_t zFoilTrans = cableSideSign*(hybDz + alFoilSh->GetX(1)); + TGeoRotation rotFoil3; + TGeoRotation rotFoil4; + if (cableSideSign > 0) { + rotFoil3 = TGeoRotation("", 90-fgkHybridAngle, -90, -90); + rotFoil4 = TGeoRotation("",-90+fgkHybridAngle, 90, 90); + } else { + rotFoil3 = TGeoRotation("", 90-fgkHybridAngle, 90, -90); + rotFoil4 = TGeoRotation("",-90+fgkHybridAngle, -90, 90); + } + TGeoCombiTrans *foiTr1 = new TGeoCombiTrans(*pipeTr2, rotFoil3); + TGeoCombiTrans *foiTr2 = new TGeoCombiTrans(*pipeTr1, rotFoil4); + AddTranslationToCombiTrans( foiTr1, -hybrVolX, hybrVolY, zFoilTrans); + AddTranslationToCombiTrans( foiTr2, hybrVolX, hybrVolY, zFoilTrans); + + virtualSeg->AddNode(alFoilVol, 1, foiTr1); + virtualSeg->AddNode(alFoilVol, 2, foiTr2); }; //********************************** if(GetDebug(1)) virtualSeg->CheckOverlaps(0.01); - virtualSeg->SetVisibility(kFALSE); return virtualSeg; -}; +} //________________________________________________________________________ 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("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(); @@ -1734,16 +2948,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreatePinSupport() { tongTrans->RegisterYourself(); TGeoCompositeShape *pinSupportShape = new TGeoCompositeShape( "ITSsddPinSupportShape","(ITSsddPinSuppCone+" - "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole"); + "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole"); - - TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //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 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -}; +} //________________________________________________________________________ @@ -1755,19 +2967,19 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() { Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle); TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.); + side1->SetName("ITSsddCPSside1"); side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.); - side1->SetVertex( 1, fgkCoolPipeSuppMaxLength/2.-diffX, - -fgkCoolPipeSuppWidthExt/2.); + side1->SetVertex( 1, 0, fgkCoolPipeSuppWidthExt/2.); side1->SetVertex( 2, fgkCoolPipeSuppMaxLength/2.-diffX, fgkCoolPipeSuppWidthExt/2.); - side1->SetVertex( 3, 0, fgkCoolPipeSuppWidthExt/2.); - side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.); - side1->SetVertex( 5, fgkCoolPipeSuppMaxLength/2., + side1->SetVertex( 3, fgkCoolPipeSuppMaxLength/2.-diffX, -fgkCoolPipeSuppWidthExt/2.); + side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.); + side1->SetVertex( 5, 0, fgkCoolPipeSuppWidthExt/2.); side1->SetVertex( 6, fgkCoolPipeSuppMaxLength/2., fgkCoolPipeSuppWidthExt/2.); - side1->SetVertex( 7, 0, fgkCoolPipeSuppWidthExt/2.); - side1->SetName("ITSsddCPSside1"); + side1->SetVertex( 7, fgkCoolPipeSuppMaxLength/2., + -fgkCoolPipeSuppWidthExt/2.); TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1",0, - fgkCoolPipeSuppAxeDist @@ -1805,18 +3017,19 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() { TGeoTube *axe = new TGeoTube("ITSsddCPSaxe",0,fgkCoolPipeSuppHoleDiam/2., fgkCoolPipeSuppTongW/4.); - TGeoRotation axeRot("ITSsddCPSaxeRot",90,90,0); + TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRot",90,90,0); TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTr", - fgkCoolPipeSuppTongW/4.,0,0,&axeRot); + fgkCoolPipeSuppTongW/4.,0,0,axeRot); axeTrans->RegisterYourself(); + //delete axeRot; // make the code crash, no idea of why !!! if(GetDebug(3)){ middle->InspectShape(); axe->InspectShape(); }; - TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //medium = ryton ? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *rytonSDD = GetMedium("RYTON$"); TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape( "ITSsddCoolPipeSuppShapeL", @@ -1829,8 +3042,10 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() { coolPipeSuppShape, rytonSDD); coolPipeSupp->SetLineColor(fColorRyton); + return coolPipeSupp; -}; +} + //________________________________________________________________________ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() { @@ -1841,6 +3056,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() { Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle); TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.); + side1->SetName("ITSsddCPSside1R"); side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.); side1->SetVertex( 1, -(fgkCoolPipeSuppMaxLength/2.-diffX), -fgkCoolPipeSuppWidthExt/2.); @@ -1853,7 +3069,6 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() { side1->SetVertex( 6, -fgkCoolPipeSuppMaxLength/2., fgkCoolPipeSuppWidthExt/2.); side1->SetVertex( 7, 0, fgkCoolPipeSuppWidthExt/2.); - side1->SetName("ITSsddCPSside1R"); TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1R",0, - fgkCoolPipeSuppAxeDist @@ -1894,10 +3109,12 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() { TGeoTube *axe = new TGeoTube("ITSsddCPSaxeR",0,fgkCoolPipeSuppHoleDiam/2., fgkCoolPipeSuppTongW/4.); - TGeoRotation axeRot("ITSsddCPSaxeRotR",90,90,0); + + TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRotR",90,90,0); TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTrR", - -fgkCoolPipeSuppTongW/4.,0,0,&axeRot); + -fgkCoolPipeSuppTongW/4.,0,0,axeRot); axeTrans->RegisterYourself(); + //delete axeRot; if(GetDebug(3)){ middle->InspectShape(); @@ -1912,17 +3129,19 @@ TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() { "+ITSsddCPSaxeBoxR:ITSsddCPSAxBoxTrR" "-ITSsddCPSaxeR:ITSsddCPSaxeTrR"); - TGeoMedium *rytonSDD = GetMedium("ITSsddCarbonM55J"); //medium = ryton ? To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *rytonSDD = GetMedium("RYTON$"); TGeoVolume *coolPipeSupp = new TGeoVolume( "ITSsddCoolPipeSupportR", coolPipeSuppShape, rytonSDD); coolPipeSupp->SetLineColor(fColorRyton); return coolPipeSupp; -}; +} //________________________________________________________________________ TGeoVolume* AliITSv11GeometrySDD::CreateBaseThermalBridge() { -// ALR 0752/8 + // + // based on ALR 0752/8 + // Double_t dy = fgkBTBaxisAtoBase - fgkRadiusBminBTB - fgkBTBthick; @@ -2008,33 +3227,41 @@ TGeoVolume* AliITSv11GeometrySDD::CreateBaseThermalBridge() { round2->InspectShape(); }; - TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J"); + TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); TGeoVolume *vBaseThermalBridge = new TGeoVolume( "ITSsddBaseThermalBridge", sBaseThermalBridge, carbonFiberLadderStruct); vBaseThermalBridge->SetLineColor(fColorCarbonFiber); return vBaseThermalBridge; -}; +} //________________________________________________________________________ -TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { +TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { // - // Return a box volume containing a end of a CF ladder. + // Return an assembly containing a end of a CF ladder. // - TGeoMedium *airSDD = GetMedium("ITSair"); - TGeoMedium *carbonFiberLadderStruct = GetMedium("ITSsddCarbonM55J"); + TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); // ITSsddCarbonM55J + TGeoMedium *stesalite = GetMedium("G10FR4$"); + TGeoMedium *phynoxSDD = GetMedium("INOX$"); + TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); Double_t length = (fgkLay3LadderLength-fgkLay3Ndet*fgkSegmentLength)/2.; Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH; Double_t underSegDH = fLay3LadderUnderSegDH; + Double_t footDZ = fgkRubyZladd3 - fgkLay3Ndet*fgkSegmentLength/2 - length/2; + // footDZ is also where to place the ruby's center in local Z + Double_t coolPipeEndLen = (fgkCoolPipeLay3Len-fgkSegmentLength*fgkLay3Ndet)/2; + if (iLay==3) { } else if (iLay==4) { - length = (fgkLay4LadderLength-fgkLay4Ndet*fgkSegmentLength)/2.; - coolPipeSuppH = fgkLay4CoolPipeSuppH; - underSegDH = fLay4LadderUnderSegDH; + length = (fgkLay4LadderLength-fgkLay4Ndet*fgkSegmentLength)/2.; + coolPipeSuppH = fgkLay4CoolPipeSuppH; + underSegDH = fLay4LadderUnderSegDH; + footDZ = fgkRubyZladd4 - fgkLay4Ndet*fgkSegmentLength/2 - length/2; + coolPipeEndLen = (fgkCoolPipeLay4Len-fgkSegmentLength*fgkLay4Ndet)/2; } else { printf("error in AliITSv11GeometrySDD::CreateEndLadder: Wrong layer"); return 0; @@ -2047,11 +3274,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { Double_t segmentLength = fgkSegmentLength; Double_t topCornerLength = fgkSegmentLength/2.-fgkLay4LaddTopCornerEnd; - TGeoBBox *endBox = new TGeoBBox("ITSsddEndLaddBox", - (fgkLadderWidth)/2, - fgkLadderHeight/2+fgkLadderSegBoxDH/2+underSegDH/2, - length/2); - TGeoVolume *virtualEnd = new TGeoVolume("ITSsddEnd",endBox, airSDD); + TGeoVolumeAssembly *virtualEnd = new TGeoVolumeAssembly("ITSsddEnd"); //********************************** // coding real matter : @@ -2063,12 +3286,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { //--- The 3 V shape corners of the Carbon Fiber Ladder //--- the top V - TGeoArb8 *cfLaddTop1 = CreateLadderSide(topCornerLength/2., halfTheta, -1, + TGeoArb8 *cfLaddTop1 = CreateLadderSide("CFladdTopCornerV1shape", + topCornerLength/2., halfTheta, -1, fgkLadderLa, fgkLadderHa, fgkLadderl); - TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1", + TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerV1", cfLaddTop1,carbonFiberLadderStruct); cfLaddTopVol1->SetLineColor(fColorCarbonFiber); - TGeoArb8 *cfLaddTop2 = CreateLadderSide( topCornerLength/2., halfTheta, 1, + TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerV2shape", + topCornerLength/2., halfTheta, 1, fgkLadderLa, fgkLadderHa, fgkLadderl); TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerV2", cfLaddTop2,carbonFiberLadderStruct); @@ -2079,12 +3304,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { virtualEnd->AddNode(cfLaddTopVol2, 1, trTop1); //--- the 2 side V - TGeoArb8 *cfLaddSide1 = CreateLadderSide( length/2., beta, -1, + TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerV1shape", + length/2., beta, -1, fgkLadderLb, fgkLadderHb, fgkLadderl); TGeoVolume *cfLaddSideVol1 = new TGeoVolume("ITSsddCFladdSideCornerV1", cfLaddSide1,carbonFiberLadderStruct); cfLaddSideVol1->SetLineColor(fColorCarbonFiber); - TGeoArb8 *cfLaddSide2 = CreateLadderSide( length/2., beta, 1, + TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerV2shape", + length/2., beta, 1, fgkLadderLb, fgkLadderHb, fgkLadderl); TGeoVolume *cfLaddSideVol2 = new TGeoVolume("ITSsddCFladdSideCornerV2", cfLaddSide2,carbonFiberLadderStruct); @@ -2111,30 +3338,30 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) )); //Euler rotation : about Z, then new X, then new Z - TGeoRotation beamRot1("", 90-2.*beta*TMath::RadToDeg(), + TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(), -beamPhiPrime*TMath::RadToDeg(), -90); - TGeoRotation beamRot2("", 90-2.*beta*TMath::RadToDeg(), + TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(), beamPhiPrime*TMath::RadToDeg(), -90); - TGeoRotation beamRot3("", 90+2.*beta*TMath::RadToDeg(), + TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(), beamPhiPrime*TMath::RadToDeg(), -90); - TGeoRotation beamRot4("", 90+2.*beta*TMath::RadToDeg(), + TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(), -beamPhiPrime*TMath::RadToDeg(), -90); TGeoCombiTrans *beamTransf1 = new TGeoCombiTrans(0.5*triangleHeight* TMath::Tan(halfTheta), fgkLadderBeamRadius/2. + tDY, - -length/2 + segmentLength/8, &beamRot1); + -length/2 + segmentLength/8, beamRot1); TGeoCombiTrans *beamTransf3 = new TGeoCombiTrans( 0.5*triangleHeight* TMath::Tan(halfTheta), fgkLadderBeamRadius/2.+tDY, - -length/2 + 3*segmentLength/8, &beamRot2); + -length/2 + 3*segmentLength/8, beamRot2); TGeoCombiTrans *beamTransf5 = new TGeoCombiTrans(-0.5*triangleHeight* TMath::Tan(halfTheta), fgkLadderBeamRadius/2.+tDY, - -length/2 + segmentLength/8, &beamRot3); + -length/2 + segmentLength/8, beamRot3); TGeoCombiTrans *beamTransf7 = new TGeoCombiTrans(-0.5*triangleHeight* TMath::Tan(halfTheta), fgkLadderBeamRadius/2. + tDY, - -length/2+3*segmentLength/8, &beamRot4); + -length/2+3*segmentLength/8, beamRot4); virtualEnd->AddNode(fLaddSegCommonVol[6], 1, beamTransf1); virtualEnd->AddNode(fLaddSegCommonVol[6], 2, beamTransf3); @@ -2142,24 +3369,27 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { virtualEnd->AddNode(fLaddSegCommonVol[6], 4, beamTransf7); //--- Beams of the bottom + TGeoRotation *bottomBeamRot1 = new TGeoRotation("",90, 90, 90); + + /* Not there actually TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius, fgkLadderWidth/2.-fgkLadderLb/3, 0, 180); TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol", bottomBeam1, carbonFiberLadderStruct); bottomBeam1Vol->SetLineColor(fColorCarbonFiber); - TGeoRotation bottomBeamRot1("",90, 90, 90); TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans(0, -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY, - -length/2+fgkSegmentLength/2, &bottomBeamRot1); + -length/2+fgkSegmentLength/2, bottomBeamRot1); virtualEnd->AddNode(bottomBeam1Vol, 1, bottomBeamTransf1); +*/ TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius, fgkLadderWidth/2.-fgkLadderLb/3, 0, 90); TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol", bottomBeam2, carbonFiberLadderStruct); bottomBeam2Vol->SetLineColor(fColorCarbonFiber); TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0, - -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,-length/2,&bottomBeamRot1); + -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,-length/2,bottomBeamRot1); virtualEnd->AddNode(bottomBeam2Vol, 1, bottomBeamTransf2); //********************************** @@ -2172,43 +3402,1656 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) { TMath::Sin(halfTheta)-coolPipeSuppH); if (fAddCoolingSyst) { - TGeoRotation rotCPS2("",-halfTheta*TMath::RadToDeg(),-90, 90); - TGeoRotation rotCPS1("", halfTheta*TMath::RadToDeg(),-90,-90); - TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL, - -fgkLadderHeight/2.+ tDY + - coolPipeSuppH+fgkLadderBeamRadius, - -length/2., &rotCPS1); - TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL, - -fgkLadderHeight/2.+ tDY + - coolPipeSuppH+fgkLadderBeamRadius, - -length/2., &rotCPS2); - - virtualEnd->AddNode(fCoolPipeSupportL, 1, transCPS1); - virtualEnd->AddNode(fCoolPipeSupportR, 1, transCPS4); + TGeoRotation *rotCPS2 = new TGeoRotation("",-halfTheta*TMath::RadToDeg(),-90, 90); + TGeoRotation *rotCPS1 = new TGeoRotation("", halfTheta*TMath::RadToDeg(),-90,-90); + TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL, + -fgkLadderHeight/2.+ tDY + + coolPipeSuppH+fgkLadderBeamRadius, + -length/2., rotCPS1); + TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL, + -fgkLadderHeight/2.+ tDY + + coolPipeSuppH+fgkLadderBeamRadius, + -length/2., rotCPS2); + + virtualEnd->AddNode(fCoolPipeSupportL, 1, transCPS1); + virtualEnd->AddNode(fCoolPipeSupportR, 1, transCPS4); }; //********************************** + //--- 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); - virtualEnd->SetVisibility(kFALSE); + 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 + + + TGeoMedium *stesalite = GetMedium("G10FR4$"); + + TGeoVolumeAssembly *virtualFoot = new TGeoVolumeAssembly("ITSsddFoot"); + + Double_t epsilon = 2e-10; + TGeoBBox *ladFootBox1 = new TGeoBBox("ladFootBox1",fgkLadBox1X/2, fgkLadFootY/2, + fgkLadFootZ/2); + TGeoTranslation *ladFootBox1Tr = new TGeoTranslation("ladFootBox1Tr", + fgkLadFootX/2-fgkLadBox1X/2,0,0); + TGeoBBox *ladFingerPrint = new TGeoBBox("ladFingerPrint",fgkLadFingerPrintX/2, + fgkLadFingerPrintY/2+epsilon, fgkLadFootZ/2+epsilon); + + TGeoTranslation *ladFingerPrintTr = new TGeoTranslation("ladFingerPrintTr", + 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", + fgkLadFootX/2-(fgkLadFootX/2-fgkRubyDX)+fgkRubyCageAxisShift, + fgkLadFootY/2-fgkRubyCageHoleY/2,0); + + 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", + fgkLadFootX/2-rubyScrewHoleLen/2, + -fgkRubyScrewShiftToCenterY, 0, rot9090); + + 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, + -(fgkLadFootY-rubyHoleLen)/2, 0, rot90); + + ladFootBox1Tr->RegisterYourself(); + ladFingerPrintTr->RegisterYourself(); + rubyCageHoleTr->RegisterYourself(); + rubyScrewHoleTr->RegisterYourself(); + rubyHoleTr->RegisterYourself(); + + TGeoCompositeShape *footRightPart = new TGeoCompositeShape( + "ladFootBox1:ladFootBox1Tr-(ladFingerPrint:ladFingerPrintTr" + "+rubyCageHole:rubyCageHoleTr+rubyScrewHole:rubyScrewHoleTr" + "+rubyHole:rubyHoleTr)"); + TGeoVolume *vFootRightPart = new TGeoVolume("vFootRightPart", + footRightPart,stesalite); + vFootRightPart->SetLineColor(fColorStesalite); + + 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 = fgkLadFootX-fgkLadBox1X-fgkLadFingerPrintX-fgkLadFingerPrintBorder; + TGeoBBox *footMiddle = new TGeoBBox("footMiddle", middleX/2, fgkLadFootMiddleY/2, + fgkLadFootZ/2); + TGeoTranslation *middleXTr = new TGeoTranslation("middleXTr", + fgkLadFootX/2-fgkLadBox1X-middleX/2, + fgkLadFootY/2-fgkLadFootMiddleY/2, 0); + + TGeoVolume *vFootMiddle = new TGeoVolume("vFootMiddle", footMiddle,stesalite); + vFootMiddle->SetLineColor(fColorStesalite); + virtualFoot->AddNode(vFootMiddle, 1, middleXTr); + + //-- + TGeoBBox *footLeftLadFinger = new TGeoBBox("footLeftLadFinger", fgkLadFingerPrintX/2, + (fgkLadFootY-fgkLadFingerPrintY)/2, + fgkLadFootZ/2); + TGeoTranslation *footLeftLadFingerTr = new TGeoTranslation("footLeftLadFingerTr", + -fgkLadFootX/2+fgkLadFingerPrintBorder+fgkLadFingerPrintX/2, + -fgkLadFingerPrintY/2, 0); + TGeoVolume *vFootLeftLadFinger = new TGeoVolume("vFootLeftLadFinger",footLeftLadFinger, + stesalite); + vFootLeftLadFinger->SetLineColor(fColorStesalite); + virtualFoot->AddNode(vFootLeftLadFinger, 1, footLeftLadFingerTr); + + //-- + TGeoBBox *footLeft = new TGeoBBox("footLeft", fgkLadFingerPrintBorder/2, + fgkLadFootY/2, + fgkLadFootZ/2); + TGeoTranslation *footLeftTr = new TGeoTranslation("footLeftTr", + -fgkLadFootX/2+fgkLadFingerPrintBorder/2, + 0, 0); + TGeoVolume *vFootLeft = new TGeoVolume("vFootLeft",footLeft,stesalite); + vFootLeft->SetLineColor(fColorStesalite); + virtualFoot->AddNode(vFootLeft, 1, footLeftTr); + if(GetDebug(3)){ // Remove compiler warning. + ladFingerPrint->InspectShape(); + ladFootBox1->InspectShape(); + rubyCageHole->InspectShape(); + rubyScrewHole->InspectShape(); + rubyHole->InspectShape(); + } + + return virtualFoot; +} + +//________________________________________________________________________ +TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateCarlosCard(Int_t iLay) { + // + // return an assembly containing the CARLOS end-ladder board + // and the heat bridge + // + + (void) iLay; + TGeoMedium *glassFiber = GetMedium("GLASS FIBER$");// glassFiber + TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip + TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2 + TGeoMedium *copper = GetMedium("COPPER$"); + TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12 + TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws + + //========================================= + // 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; +} //________________________________________________________________________ -TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { +Int_t AliITSv11GeometrySDD::CreateLVCard() { + // + // Creates the assemblies containing the LV cards (left and right) // - // return a box containing the SDD sensor + + TGeoMedium *glassFiber = GetMedium("GLASS FIBER$");// glassFiber + TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip + TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2 + TGeoMedium *copper = GetMedium("COPPER$"); + TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12 + TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws + + fCardLVL = new TGeoVolumeAssembly("ITSsddLVCardLeft"); + fCardLVR = new TGeoVolumeAssembly("ITSsddLVCardRight"); + + // 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 = fgkLVcardZ+fgkLVcardCuZ; + AliITSv11GeomCableFlat cardLV("cardLV", fgkLVcardY, carLVfullThick); // name, width, thickness + cardLV.SetNLayers(2); + 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] = fgkLVcardY/2; + p1[2] = 0; + p2[0] = fgkLVcardX; + p2[1] = fgkLVcardY/2; + p2[2] = 0; + 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, 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] = (fgkLVChip0PosX + fgkLVChip0X/2); + p2[1] = fgkLVChip0PosY; + p2[2] = carLVfullThick/2 + chip0fullThick/2; + 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, 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] = (fgkLVChip1PosX+fgkLVChip1X/2); + p2[1] = fgkLVChip1PosY; + p2[2] = carLVfullThick/2 + chip1fullThick/2; + 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, 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] = (fgkLVChip2PosX+fgkLVChip2X/2); + p2[1] = fgkLVChip2PosY; + p2[2] = carLVfullThick/2 + chip2fullThick/2; + 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, 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] = (fgkLVChip3PosX+fgkLVChip3X/2); + p2[1] = fgkLVChip3PosY; + p2[2] = -carLVfullThick/2 - chip3fullThick/2; + 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" , + fgkLVcoolX1/2, fgkLVcoolY1/2, fgkLVcoolZ1/2); + + TGeoTranslation *alLVcooling1Tr = new TGeoTranslation("alLVcooling1Tr", + (fgkLVcoolX1/2+fgkLVcoolX2), + fgkLVcoolPosY+fgkLVcoolY1/2, + carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2); + TGeoTranslation *alLVcooling1TrB = new TGeoTranslation("alLVcooling1TrB", + (fgkLVcoolX1/2+fgkLVcoolX2), + fgkLVcoolPosY+fgkLVcoolY1/2, + -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2)); + + TGeoVolume *vAlLVcooling1 = new TGeoVolume("vAlLVcooling1",alLVcooling1, + alCu12SDD); + vAlLVcooling1->SetLineColor(2); + + //-- + TGeoBBox * alLVcooling2 = new TGeoBBox("lLVcooling2" , + fgkLVcoolX2/2, fgkLVcoolY2/2, fgkLVcoolZ2/2); + TGeoTranslation *alLVcooling2Tr = new TGeoTranslation("alLVcooling2Tr", + (fgkLVcoolX2/2), + fgkLVcoolPosY+fgkLVcoolY1/2, + carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2); + TGeoTranslation *alLVcooling2TrB = new TGeoTranslation("alLVcooling2TrB", + (fgkLVcoolX2/2), + fgkLVcoolPosY+fgkLVcoolY1/2, + -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2)); + + TGeoVolume *vAlLVcooling2 = new TGeoVolume("vAlLVcooling2",alLVcooling2, + alCu12SDD); + vAlLVcooling2->SetLineColor(2); + + //-- + Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z) + +fgkLVcoolZ1*2.); + TGeoBBox * alLVcooling3 = new TGeoBBox("lLVcooling3" , + fgkLVcoolX3/2, fgkLVcoolY3/2, alLVcoolZ3/2); + TGeoTranslation *alLVcooling3Tr = new TGeoTranslation("alLVcooling3Tr", + (-fgkLVcoolX3/2), + fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2, + 0); + TGeoVolume *vAlLVcooling3 = new TGeoVolume("vAlLVcooling3",alLVcooling3,alCu12SDD); + vAlLVcooling3->SetLineColor(2); + + //=== 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 kTRUE; +} + +//________________________________________________________________________ +TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateHVCard(Int_t iLay){ + // + // return an assembly containing the HV card // + iLay = iLay; + + TGeoMedium *ceramic = GetMedium("CERAMICS$"); // ceramicHVcard + TGeoMedium *medSMDcapaMiddle = GetMedium("SDD X7R capacitors$"); // check if different + TGeoMedium *medSMDcapaEnd = GetMedium("SDD X7R capacitors$"); // check if different + TGeoMedium *stainless = GetMedium("INOX$"); // ITSspdStainlesSteal ??????????? + TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ITS_ITSsddKAPTON_POLYCH2 ??????????? + TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12 + + TGeoVolumeAssembly *highVCard = new TGeoVolumeAssembly("ITSsddHVCard"); + + //==================================== + //--- the card itself + TGeoBBox *ceramicCard = new TGeoBBox("ceramCard", fgkHVCardCeramX/2, + fgkHVCardCeramY/2, fgkHVCardCeramZ/2); + TGeoVolume *vCeramicCard = new TGeoVolume("vCeramCard", ceramicCard, ceramic); + vCeramicCard->SetLineColor(38);// or 9 blue slightly dark + + highVCard->AddNode(vCeramicCard, 1, 0); + + + //==================================== + //--- capacitors + + // capa1 + TGeoBBox *capa1Middle = new TGeoBBox("cardHVCapa1Middle", fgkHVCardCapa1X/2, + fgkHVCardCapa1Ymid/2, fgkHVCardCapa1Z/2); + TGeoVolume *vCapa1Middle = new TGeoVolume("vCardHVCapa1Middle",capa1Middle, + medSMDcapaMiddle); + + TGeoBBox *capa1End = new TGeoBBox("cardHVCapa1End", fgkHVCardCapa1X/2, + fgkHVCardCapa1Yend/2, fgkHVCardCapa1Z/2); + TGeoVolume *vCapa1End = new TGeoVolume("vCardHVCapa1End",capa1End, + medSMDcapaEnd); + vCapa1End->SetLineColor(18);// grey silver + TGeoTranslation *capa1EndTr1 = new TGeoTranslation("cardHVcapa1EndTr1", 0, + (fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0); + TGeoTranslation *capa1EndTr2 = new TGeoTranslation("cardHVcapa1EndTr2", 0, + -(fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0); + + TGeoTranslation *capa1PosTr = new TGeoTranslation("cardHVcapa1PosTr", + fgkHVCardCapa1PosX, fgkHVCardCapa1PosY, + -fgkHVCardCeramZ/2-fgkHVCardCapa1Z/2); + + TGeoVolumeAssembly *capa1 = new TGeoVolumeAssembly("cardHVCapa1"); + capa1->AddNode(vCapa1Middle, 1,0); + capa1->AddNode(vCapa1End, 1, capa1EndTr1); + capa1->AddNode(vCapa1End, 2, capa1EndTr2); + + highVCard->AddNode(capa1, 1, capa1PosTr); + + // capa2 + TGeoBBox *capa2Middle = new TGeoBBox("cardHVCapa2Middle", fgkHVCardCapa2X/2, + fgkHVCardCapa2Ymid/2, fgkHVCardCapa2Z/2); + TGeoVolume *vCapa2Middle = new TGeoVolume("vCardHVCapa2Middle",capa2Middle, + medSMDcapaMiddle); + + TGeoBBox *capa2End = new TGeoBBox("cardHVCapa2End", fgkHVCardCapa2X/2, + fgkHVCardCapa2Yend/2, fgkHVCardCapa2Z/2); + TGeoVolume *vCapa2End = new TGeoVolume("vCardHVCapa2End",capa2End, + medSMDcapaEnd); + vCapa2End->SetLineColor(18);// grey silver + TGeoTranslation *capa2EndTr1 = new TGeoTranslation("cardHVcapa2EndTr1", 0, + (fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0); + TGeoTranslation *capa2EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2", 0, + -(fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0); + + TGeoTranslation *capa2PosTr = new TGeoTranslation("cardHVcapa2PosTr", + fgkHVCardCapa2PosX, fgkHVCardCapa2PosY, + -fgkHVCardCeramZ/2-fgkHVCardCapa2Z/2); + + TGeoVolumeAssembly *capa2 = new TGeoVolumeAssembly("cardHVCapa2"); + capa2->AddNode(vCapa2Middle, 1,0); + capa2->AddNode(vCapa2End, 1, capa2EndTr1); + capa2->AddNode(vCapa2End, 2, capa2EndTr2); + + highVCard->AddNode(capa2, 1, capa2PosTr); + + // capa3 + TGeoBBox *capa3Middle = new TGeoBBox("cardHVCapa3Middle", fgkHVCardCapa3Xmid/2, + fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2); + TGeoVolume *vCapa3Middle = new TGeoVolume("vCardHVCapa3Middle",capa3Middle, + medSMDcapaMiddle); + + TGeoBBox *capa3End = new TGeoBBox("cardHVCapa3End", fgkHVCardCapa3Xend/2, + fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2); + TGeoVolume *vCapa3End = new TGeoVolume("vCardHVCapa3End",capa3End, + medSMDcapaEnd); + vCapa3End->SetLineColor(18);// grey silver + + TGeoTranslation *capa3EndTr1 = new TGeoTranslation("cardHVcapa3EndTr1", + (fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0); + TGeoTranslation *capa3EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2", + -(fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0); + + TGeoVolumeAssembly *capa3 = new TGeoVolumeAssembly("cardHVCapa3"); + capa3->AddNode(vCapa3Middle, 1,0); + capa3->AddNode(vCapa3End, 1, capa3EndTr1); + capa3->AddNode(vCapa3End, 2, capa3EndTr2); + + TGeoTranslation *capa3PosTr1 = new TGeoTranslation("cardHVcapa3PosTr1", + fgkHVCardCapa3PosX1, fgkHVCardCapa3PosY1, + -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2); + + TGeoTranslation *capa3PosTr2 = new TGeoTranslation("cardHVcapa3PosTr2", + fgkHVCardCapa3PosX2, fgkHVCardCapa3PosY1, + -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2); + + TGeoTranslation *capa3PosTr3 = new TGeoTranslation("cardHVcapa3PosTr3", + fgkHVCardCapa3PosX3, fgkHVCardCapa3PosY2, + -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2); + + TGeoTranslation *capa3PosTr4 = new TGeoTranslation("cardHVcapa3PosTr4", + fgkHVCardCapa3PosX4, fgkHVCardCapa3PosY2, + -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2); + + TGeoTranslation *capa3PosTr5 = new TGeoTranslation("cardHVcapa3PosTr5", + fgkHVCardCapa3PosX5, fgkHVCardCapa3PosY3, + -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2); + + highVCard->AddNode(capa3, 1, capa3PosTr1); + highVCard->AddNode(capa3, 2, capa3PosTr2); + highVCard->AddNode(capa3, 3, capa3PosTr3); + highVCard->AddNode(capa3, 4, capa3PosTr4); + highVCard->AddNode(capa3, 5, capa3PosTr5); + + //==================================== + //--- connexions to LV card + + Double_t fgkConnexLVHVdiam1 = 0.8*fgkmm; + Double_t fgkConnexLVHVdiam2 = 2*fgkmm; + Double_t fgkConnexLVHVlen = 6.2*fgkmm; + Double_t fgkConnexLVHVx = 3*fgkmm; + Double_t fgkConnexLVHVy1 = 8*fgkmm; + Double_t fgkConnexLVHVdy = 2.5*fgkmm; + + TGeoTube *connexLVHVmetal = new TGeoTube("connexLVHVmetal",0, + fgkConnexLVHVdiam1/2,fgkConnexLVHVlen/2); + TGeoTube *connexLVHVplastic = new TGeoTube("connexLVHVplastic", + fgkConnexLVHVdiam1/2, + fgkConnexLVHVdiam2/2, + fgkConnexLVHVlen/2); + TGeoVolume *vConnexLVHVmetal = new TGeoVolume("ITSsddConnexLVHVmetal", + connexLVHVmetal, stainless); + TGeoVolume *vConnexLVHVplast = new TGeoVolume("ITSsddConnexLVHVplast", + connexLVHVplastic, plastic); + vConnexLVHVmetal->SetLineColor(10);// white + vConnexLVHVplast->SetLineColor(12); // dark grey + + TGeoVolumeAssembly *connexion = new TGeoVolumeAssembly("ITSsddConnexLVHV"); + connexion->AddNode(vConnexLVHVmetal, 1, 0); + connexion->AddNode(vConnexLVHVplast, 1, 0); + + TGeoTranslation *trConnexion1 = new TGeoTranslation(-fgkConnexLVHVx,fgkConnexLVHVy1, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + TGeoTranslation *trConnexion2 = new TGeoTranslation( fgkConnexLVHVx,fgkConnexLVHVy1, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + + TGeoTranslation *trConnexion3 = new TGeoTranslation(-fgkConnexLVHVx, + fgkConnexLVHVy1+fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + TGeoTranslation *trConnexion4 = new TGeoTranslation( fgkConnexLVHVx, + fgkConnexLVHVy1+fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + + TGeoTranslation *trConnexion5 = new TGeoTranslation(-fgkConnexLVHVx, + fgkConnexLVHVy1+2*fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + TGeoTranslation *trConnexion6 = new TGeoTranslation( fgkConnexLVHVx, + fgkConnexLVHVy1+2*fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + + TGeoTranslation *trConnexion7 = new TGeoTranslation(-fgkConnexLVHVx, + fgkConnexLVHVy1+3*fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + TGeoTranslation *trConnexion8 = new TGeoTranslation( fgkConnexLVHVx, + fgkConnexLVHVy1+3*fgkConnexLVHVdy, + -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 ); + + highVCard->AddNode(connexion, 1, trConnexion1); + highVCard->AddNode(connexion, 2, trConnexion2); + highVCard->AddNode(connexion, 3, trConnexion3); + highVCard->AddNode(connexion, 4, trConnexion4); + highVCard->AddNode(connexion, 5, trConnexion5); + highVCard->AddNode(connexion, 6, trConnexion6); + highVCard->AddNode(connexion, 7, trConnexion7); + highVCard->AddNode(connexion, 8, trConnexion8); + + //==================================== + //--- cooling pieces + + TGeoBBox *cardHVcool1 = new TGeoBBox("cardHVcool1",fgkHVCardCool1X/2, + fgkHVCardCool1Y/2, fgkHVCardCool1Z/2); + + + TGeoBBox *cardHVcool2 = new TGeoBBox("cardHVcool2",fgkHVCardCool2X/2, + fgkHVCardCool2Y/2, fgkHVCardCool2Z/2); + + TGeoBBox *cardHVcool3 = new TGeoBBox("cardHVcool3",fgkHVCardCool3X/2, + fgkHVCardCool3Y/2, fgkHVCardCool3Z/2); + + TGeoVolume *vCardHVcool1 = new TGeoVolume("vCardHVcool1",cardHVcool1, + alCu12SDD); + TGeoVolume *vCardHVcool2 = new TGeoVolume("vCardHVcool2",cardHVcool2, + alCu12SDD); + TGeoVolume *vCardHVcool3 = new TGeoVolume("vCardHVcool3",cardHVcool3, + alCu12SDD); + // 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 + vCardHVcool3->SetLineColor(2); //red + + TGeoTranslation *cool1Tr1 = new TGeoTranslation("cardHVcool1Tr1", + fgkHVCardCeramX/2-fgkHVCardCool1X/2, + -fgkHVCardCoolDY+fgkHVCardCool1Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool1Z/2); + TGeoTranslation *cool1Tr2 = new TGeoTranslation("cardHVcool1Tr2", + -fgkHVCardCeramX/2+fgkHVCardCool1X/2, + -fgkHVCardCoolDY+fgkHVCardCool1Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool1Z/2); + + highVCard->AddNode(vCardHVcool1, 1, cool1Tr1); + highVCard->AddNode(vCardHVcool1, 2, cool1Tr2); + + TGeoTranslation *cool2Tr1 = new TGeoTranslation("cardHVcool2Tr1", + fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X/2, + -fgkHVCardCoolDY-fgkHVCardCool2Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool2Z/2); + + TGeoTranslation *cool2Tr2 = new TGeoTranslation("cardHVcool2Tr2", + -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X/2, + -fgkHVCardCoolDY-fgkHVCardCool2Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool2Z/2); + + highVCard->AddNode(vCardHVcool2, 1, cool2Tr1); + highVCard->AddNode(vCardHVcool2, 2, cool2Tr2); + + TGeoTranslation *cool3Tr1 = new TGeoTranslation("cardHVcool2Tr1", + fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2, + -fgkHVCardCoolDY-fgkHVCardCool3Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2); + + TGeoTranslation *cool3Tr2 = new TGeoTranslation("cardHVcool2Tr2", + -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2, + -fgkHVCardCoolDY-fgkHVCardCool3Y/2, + fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2); + + 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; +} + + +//________________________________________________________________________ +TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) { +// +// return an assembly containing the LV, HV and Carlos cards of one ladder +// and their cooling system +// + + TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12 + 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; + Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3; + Int_t nCards = 3; + + if (iLay==4) { + endLadPipeUlength = fgkEndLadPipeUlengthLay4; + endLadPipeArmZ = fgkEndLadPipeArmZLay4; + nCards = 4; + } + + AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2); + endLadderPipe.SetNLayers(2); + endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4); + endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox); + + Double_t coolUzPos = fgkEndLadPipeOuterDiam/2+2.*fgkmm; //it is the x coord of the axis + // of the U colling pipe in its center + + Double_t coordA[3] = { fgkEndLadPipeUwidth/2, 0, endLadPipeUlength+coolUzPos}; + Double_t vectA[3] = {0,0,1}; + + Double_t coordB[3] = { fgkEndLadPipeUwidth/2,0, fgkEndLadPipeRadius+coolUzPos}; + Double_t vectB[3] = {0,0,1}; + + Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, 0, coolUzPos}; + Double_t vectC[3] = {1,0,0}; + + Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, 0, coolUzPos}; + Double_t vectD[3] = {-1,0,0}; + + Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, 0, fgkEndLadPipeRadius+coolUzPos}; + Double_t vectE[3] = {0,0,-1}; + + Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,0, 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,0,armZ); + TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2", + fgkEndLadPipeUwidth/2,0,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 cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2 + +fgkEndLadPipeArmBoxDX); + Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3 + +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY); + + 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; iCardAddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR); + endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL); + } + + //=********************************* + //--- HV cards + TGeoVolumeAssembly *cardHV = fCardHV; + + Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y + + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY); + + Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z + -(fgkHVCardCeramZ)/2); + + for (Int_t iCard=0; iCardAddNode(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; iCardAddNode(assemblySupCarlos, iCard, carlosPos); + } + + return endLadderCards; +} + + +//________________________________________________________________________ +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 +// + + TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12 + 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 OPTICFIB$"); + TGeoMedium *polyurethane = GetMedium("POLYURETHANE$"); + + Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3; + Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3; + Int_t nCards = 3; + Double_t rREF = fgkEndLaddCardsShortRadiusLay3; + Double_t deltaZcables = 0; + // reference radius corresponding to local y=0 + + if (iLay==4) { + endLadPipeUlength = fgkEndLadPipeUlengthLay4; + endLadPipeArmZ = fgkEndLadPipeArmZLay4; + nCards = 4; + rREF = fgkEndLaddCardsShortRadiusLay4; + deltaZcables = 2.8*fgkmm; + } + + Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2 + +fgkEndLadPipeArmBoxDX); + Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3 + +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY); + + Double_t rMin = rREF + cardLVyShift; + // (The LV card is defining rMin because it is the lower object) + + Double_t thickTotCable = 0.5; + + //================================== + //--- 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 + 23.6*fgkmm + 3.0*fgkcm + deltaZcables; + Double_t cableSectionZ2 = zMax + 23.6*fgkmm + 4.0*fgkcm + deltaZcables; + // Those numbers are to be fixed to stick the maximum to the SDD cone + // (hardcoded numbers are ugly, but it's easier to find where to stop) + + 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 + + AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2); + endLadderPipe.SetNLayers(2); + endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4); + endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox); + + Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos}; + Double_t vectA[3] = {0,0,1}; + + Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos}; + Double_t vectB[3] = {0,0,1}; + + 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; iCardAddNode(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; iCardAddNode(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; iCardAddNode(assemblySupCarlos, iCard, carlosPos); + } + + + //=********************************* + //--- Cables + + + Double_t sectionV = (fgkSectionCuPerMod+fgkSectionPlastPerMod + + fgkSectionGlassPerMod)*nCards + + fgkSectionCoolPolyuEL + fgkSectionCoolWaterEL; + // We fix thickness, then width is calculated accordingly + Double_t width = sectionV/thickTotCable; + Double_t thickCu = thickTotCable*fgkSectionCuPerMod + / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL); + Double_t thickPlast = thickTotCable*fgkSectionPlastPerMod + / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL); + Double_t thickGlass = thickTotCable*fgkSectionGlassPerMod + / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL); + + Double_t thickCoolPolyu = thickTotCable*fgkSectionCoolPolyuEL + / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL); + Double_t thickCoolWater = thickTotCable*fgkSectionCoolWaterEL + / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL); + + AliITSv11GeomCableFlat cable("SDDcableEndLadder",width,thickTotCable); + cable.SetNLayers(5); + cable.SetLayer(0, thickCu, copper, kRed); + cable.SetLayer(1, thickPlast, plastic, kYellow); + cable.SetLayer(2, thickGlass, opticalFiber, kGreen); + cable.SetLayer(3, thickCoolPolyu, polyurethane, kGray); + cable.SetLayer(4, thickCoolWater, coolerMediumSDD, kBlue); + + 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... + + Double_t zEndCable = GetConeZ(cablesRadius-thickTotCable/2, cableSectionR1, + cableSectionR2,cableSectionZ1,cableSectionZ2); + + 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); + + // The earth cable + TGeoTorus *earthShape = new TGeoTorus(rMax-fgkEndLadderEarthCableR, + 0., fgkEndLadderEarthCableR, + phi0, dphi); // same as containerShape + + TGeoVolume *earthCable = new TGeoVolume("SDDcableEndLadderEarthCable", + earthShape, copper); + + endLadderCards->AddNode(earthCable, 1, + new TGeoTranslation(0, 0, fgkDistEndLaddCardsLadd+1)); + + return endLadderCards; +} + +//________________________________________________________________________ +TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateSupportRing(Int_t iLay) { +// +// return an assembly of the support rings, attaching the ladders to the cone +// + + + iLay = iLay; + + TGeoMedium *stainless = GetMedium("INOX$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoVolumeAssembly *supportRing = new TGeoVolumeAssembly("supportRing"); + + + //********************************** + // ruby cage + + Double_t fgkRubyCageX = 9*fgkmm; + Double_t fgkRubyCageY = 5.5*fgkmm; + Double_t fgkRubyCageZ = 8*fgkmm; + Double_t fgkRubyCageInternSide = 5.*fgkmm; //side of the internal square + Double_t fgkRubyCageHoleDX = 2.*fgkmm; + Double_t fgkRubyCageVIntern = 5.42*fgkmm; + Double_t fgkRubyCageScrewHoleR = 4.5/2*fgkmm; + Double_t fgkRubyCageScrewHoleY = 1.5*fgkmm; + + TGeoBBox *rubyCageBox = new TGeoBBox("rubyCageBox",fgkRubyCageX/2,fgkRubyCageY/2, + fgkRubyCageZ/2); + + Double_t epsilon = 1e-10; //dummy epsilon to force the gl viewer to show holes + + // pieces common to both square and V cages + TGeoBBox *rubyCageInternBox = new TGeoBBox("rubyCageInternBox",fgkRubyCageInternSide/2, + fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2); + + TGeoTube *screwHole = new TGeoTube("screwHole", 0, fgkRubyCageScrewHoleR, + fgkRubyCageHoleDX/2+epsilon); + + TGeoRotation *rotV = new TGeoRotation("", 90,90,-90); + TGeoCombiTrans *trScrewHole = new TGeoCombiTrans("trScrewHole", + fgkRubyCageX/2-fgkRubyCageHoleDX/2, + -fgkRubyCageY/2+fgkRubyCageScrewHoleY,0,rotV); + trScrewHole->RegisterYourself(); + + TGeoBBox *screwHoleFoot = new TGeoBBox("screwHoleFoot",fgkRubyCageHoleDX/2+epsilon, + fgkRubyCageScrewHoleY/2+epsilon, fgkRubyCageScrewHoleR); + TGeoTranslation *trScrewHoleFoot = new TGeoTranslation("trScrewHoleFoot", + fgkRubyCageX/2-fgkRubyCageHoleDX/2, + -fgkRubyCageY/2+fgkRubyCageScrewHoleY/2, 0); + trScrewHoleFoot->RegisterYourself(); + + + // pieces which differ + Double_t rubyCageVInternBoxX = fgkRubyCageVIntern - fgkRubyCageInternSide/2; + + TGeoBBox *rubyCageVInternBox = new TGeoBBox("rubyCageVInternBox",rubyCageVInternBoxX/2, + fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2); + + TGeoTranslation *trRubyCageVInternBox = new TGeoTranslation("trRubyCageVInternB", + fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX/2,0,0); + trRubyCageVInternBox->RegisterYourself(); + + TGeoTrd1 *rubyCageVInternTriangl = new TGeoTrd1("rubyCageVInternTriangl", 0, + fgkRubyCageInternSide/2, fgkRubyCageY/2+epsilon, + fgkRubyCageInternSide/4); + + TGeoCombiTrans *trRubyCageVInternTriangl = new TGeoCombiTrans("trRubyCageVInternTriangl", + fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX-fgkRubyCageInternSide/4 + +epsilon,0,0, rotV ); + trRubyCageVInternTriangl->RegisterYourself(); + + //--- + TGeoCompositeShape *rubyCageSquare = new TGeoCompositeShape("rubyCageSquare", + "rubyCageBox-(rubyCageInternBox" + "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)"); + + TGeoVolume *vRubyCageSquare = new TGeoVolume("vRubyCageSquare", + rubyCageSquare, stainless); + vRubyCageSquare->SetLineColor(10); + + TGeoCompositeShape *rubyCageV = new TGeoCompositeShape("rubyCageV", + "rubyCageBox-(rubyCageVInternBox:trRubyCageVInternB" + "+rubyCageVInternTriangl:trRubyCageVInternTriangl" + "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)"); + TGeoVolume *vRubyCageV = new TGeoVolume("vRubyCageV", rubyCageV, stainless); + vRubyCageV->SetLineColor(10); + + if(GetDebug(3)) { // Remove compiler warning. + rubyCageBox->InspectShape(); + rubyCageInternBox->InspectShape(); + screwHole->InspectShape(); + screwHoleFoot->InspectShape(); + rubyCageVInternBox->InspectShape(); + rubyCageVInternTriangl->InspectShape(); + } + + supportRing->AddNode(vRubyCageSquare, 0, 0); + //supportRing->AddNode(vRubyCageV, 0, 0); + return supportRing; +} + + + +//________________________________________________________________________ +void AliITSv11GeometrySDD::CreateSDDsensor() { +// +// return a box containing the SDD sensor +// + + TGeoMedium *airSDD = GetMedium("SDD AIR$"); + TGeoMedium *siliconSDD = GetMedium("SDD SI insensitive$"); // ITSsddSi + TGeoMedium *siliconSDDsens = GetMedium("SI$"); // ITSsddSi + TGeoMedium *alSDD = GetMedium("AL$"); // ITSal + TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2 + TGeoMedium *glassSDD = GetMedium("STDGLASS$"); // StdGlass Double_t rWraping = fgkWaferThickness/2+fgkWaHVcableAlThick+fgkWaHVcablePolyThick; Double_t witdhCableBox = (fgkWaHVcableWitdh - TMath::Pi()*rWraping)/2; + // width : in the beam direction ! Double_t sensoxBoxLength = ( fgkWaferLength + 2*(rWraping+witdhCableBox-fgkWaHVcableDW) ); @@ -2216,25 +5059,44 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { Double_t sensoxBoxThick = fgkWaferThickness + 2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick); +// cout << "fgkWaferLength=" << fgkWaferLength << " sensoxBoxLength="<< sensoxBoxLength <SetLineColor(fColorSilicon); - TGeoBBox *sensBox = new TGeoBBox("ITSsddSensorSensBox", - fgkWaferWidthSens/2,fgkWaferThickSens/2,fgkWaferLengthSens/2); - TGeoVolume *sensVol=new TGeoVolume(fgSDDsensitiveVolName,sensBox,siliconSDD); - sensVol->SetLineColor(fColorSilicon); - - wafer->AddNode(sensVol, 1, 0); - virtualSensor->AddNode(wafer, 1, 0); + fgkWaferWidth/2, fgkWaferThickness/2, fgkWaferLength/2); + + + TGeoVolume *wafer3 = new TGeoVolume("ITSsddWafer3", waferShape, siliconSDD); + wafer3->SetLineColor(fColorSilicon); + TGeoBBox *sensBox3 = new TGeoBBox("ITSsddSensorSensBox3", + fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2); + TGeoVolume *sensVol3 = new TGeoVolume(fgSDDsensitiveVolName3,sensBox3, siliconSDDsens); + sensVol3->SetLineColor(fColorSilicon+5); + wafer3->AddNode(sensVol3, 1, 0); + fSDDsensor3->AddNode(wafer3, 1, 0); + + TGeoVolume *wafer4 = new TGeoVolume("ITSsddWafer4", waferShape, siliconSDD); + wafer4->SetLineColor(fColorSilicon); + TGeoBBox *sensBox4 = new TGeoBBox("ITSsddSensorSensBox4", + fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2); + TGeoVolume *sensVol4 = new TGeoVolume(fgSDDsensitiveVolName4,sensBox4, siliconSDDsens); + sensVol4->SetLineColor(fColorSilicon+5); + wafer4->AddNode(sensVol4, 1, 0); + fSDDsensor4->AddNode(wafer4, 1, 0); }; //**************************** @@ -2256,10 +5118,15 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { TGeoTranslation *glassTr4 = new TGeoTranslation("",-fgkGlassDXOnSensor, fgkWaferThickness/2+fgkSensorGlassLY/2, -fgkGlassDZOnSensor); - virtualSensor->AddNode(vGlass, 1, glassTr1); - virtualSensor->AddNode(vGlass, 2, glassTr2); - virtualSensor->AddNode(vGlass, 3, glassTr3); - virtualSensor->AddNode(vGlass, 4, glassTr4); + fSDDsensor3->AddNode(vGlass, 1, glassTr1); + fSDDsensor3->AddNode(vGlass, 2, glassTr2); + fSDDsensor3->AddNode(vGlass, 3, glassTr3); + fSDDsensor3->AddNode(vGlass, 4, glassTr4); + + fSDDsensor4->AddNode(vGlass, 1, glassTr1); + fSDDsensor4->AddNode(vGlass, 2, glassTr2); + fSDDsensor4->AddNode(vGlass, 3, glassTr3); + fSDDsensor4->AddNode(vGlass, 4, glassTr4); //**************************** // Wrap-around cable @@ -2270,7 +5137,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { waHVCable.SetNLayers(2); waHVCable.SetLayer(0, fgkWaHVcablePolyThick,polyhamideSDD,fColorPolyhamide); waHVCable.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl); - waHVCable.SetInitialNode(virtualSensor); + waHVCable.SetInitialNode(fSDDsensor3); Double_t x1[3], x2[3], vX[3] = {1,0,0}; x1[0] = -fgkWaHVcableLength/2; @@ -2280,16 +5147,20 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { x1[2] = fgkWaferLength/2+waHVCable.GetWidth()/2-fgkWaHVcableDW; x2[2] = x1[2]; - waHVCable.AddCheckPoint(virtualSensor, 0, x1, vX); - waHVCable.AddCheckPoint(virtualSensor, 1, x2, vX); - waHVCable.CreateAndInsertCableSegment(1,-90); + waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX); + waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX); + TGeoCombiTrans *ctSegment = 0; + TGeoVolume* segment = waHVCable.CreateAndInsertBoxCableSegment(1,-90, &ctSegment); + fSDDsensor4->AddNode(segment, 1, ctSegment); + x1[1] = -x1[1]; x2[1] = x1[1]; waHVCable.SetName("ITSsddWaHVCableD"); waHVCable.ResetPoints(); - waHVCable.AddCheckPoint(virtualSensor, 0, x1, vX); - waHVCable.AddCheckPoint(virtualSensor, 1, x2, vX); - waHVCable.CreateAndInsertCableSegment(1, 90); + waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX); + waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX); + segment = waHVCable.CreateAndInsertBoxCableSegment(1, 90, &ctSegment); + fSDDsensor4->AddNode(segment, 1, ctSegment); AliITSv11GeomCableRound waHVCableFold("ITSsddWaHVCableFold", rWraping); @@ -2298,14 +5169,16 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { waHVCableFold.SetLayer(0, fgkWaferThickness/2+fgkWaHVcablePolyThick, polyhamideSDD, fColorPolyhamide); waHVCableFold.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl); - waHVCableFold.SetInitialNode(virtualSensor); + waHVCableFold.SetInitialNode(fSDDsensor3); x1[1] = 0; x2[1] = 0; x1[2] = fgkWaferLength/2-fgkWaHVcableDW+witdhCableBox; x2[2] = x1[2]; - waHVCableFold.AddCheckPoint(virtualSensor, 0, x1, vX); - waHVCableFold.AddCheckPoint(virtualSensor, 1, x2, vX); - waHVCableFold.CreateAndInsertCableSegment(1); + waHVCableFold.AddCheckPoint(fSDDsensor3, 0, x1, vX); + waHVCableFold.AddCheckPoint(fSDDsensor3, 1, x2, vX); + segment = waHVCableFold.CreateAndInsertCableSegment(1, &ctSegment); + fSDDsensor4->AddNode(segment, 1, ctSegment); + //**************************** // transition cable @@ -2360,12 +5233,19 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { vHeadAlComp->SetLineColor(fColorAl); - TGeoRotation rotHead("",0,90,0); +// TGeoRotation rotHead("",0,90,0); +// TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2, +// -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2, +// &rotHead); + TGeoRotation *rotHead = new TGeoRotation("",0,90,0); TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2, -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2, - &rotHead); - virtualSensor->AddNode(vHeadPolyComp,1,rotHeadTr); - virtualSensor->AddNode(vHeadAlComp,1,rotHeadTr); + rotHead); + + fSDDsensor3->AddNode(vHeadPolyComp,1,rotHeadTr); + fSDDsensor3->AddNode(vHeadAlComp,1,rotHeadTr); + fSDDsensor4->AddNode(vHeadPolyComp,1,rotHeadTr); + fSDDsensor4->AddNode(vHeadAlComp,1,rotHeadTr); //--- AliITSv11GeomCableFlat transitHVCable("ITSsddHVtransitCenter", @@ -2375,7 +5255,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { transitHVCable.SetLayer(0, fgkTransitHVPolyThick,polyhamideSDD, fColorPolyhamide); transitHVCable.SetLayer(1, fgkTransitHVAlThick, alSDD, fColorAl); - transitHVCable.SetInitialNode(virtualSensor); + transitHVCable.SetInitialNode(fSDDsensor3); x1[0] = -fgkTransitHVHeadLX/2; x2[0] = -x1[0]; @@ -2383,9 +5263,11 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { x2[1] = x1[1]; x1[2] = 0; x2[2] = 0; - transitHVCable.AddCheckPoint(virtualSensor, 0, x1, vX); - transitHVCable.AddCheckPoint(virtualSensor, 1, x2, vX); - transitHVCable.CreateAndInsertCableSegment(1,-90); + transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX); + transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX); + segment = transitHVCable.CreateAndInsertBoxCableSegment(1,-90,&ctSegment); + fSDDsensor4->AddNode(segment, 1, ctSegment); + transitHVCable.ResetPoints(); transitHVCable.SetName("ITSsddHVtransitTail"); transitHVCable.SetWidth(fgkTransitHVtailWidth); @@ -2394,9 +5276,10 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { x1[2] = -fgkTransitHVBondingLZ/2; x2[2] = -fgkTransitHVBondingLZ/2-fgkTransitHVtailLength; Double_t vZ[3] = {0,0,1}; - transitHVCable.AddCheckPoint(virtualSensor, 0, x1, vZ); - transitHVCable.AddCheckPoint(virtualSensor, 1, x2, vZ); - transitHVCable.CreateAndInsertCableSegment(1,0); + transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vZ); + transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vZ); + segment = transitHVCable.CreateAndInsertBoxCableSegment(1,0, &ctSegment); + fSDDsensor4->AddNode(segment, 1, ctSegment); //--- TGeoArb8 *sideLeft = new TGeoArb8( fgkTransitHVPolyThick/2 ); @@ -2423,28 +5306,39 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { 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); - - TGeoRotation rotSide("",0,-90,0); - TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0, - (fgkWaferThickness+fgkTransitHVPolyThick)/2, - -fgkTransitHVBondingLZ/2,&rotSide); + // 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, +// (fgkWaferThickness+fgkTransitHVPolyThick)/2, +// -fgkTransitHVBondingLZ/2,&rotSide); +// TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0, +// (fgkWaferThickness+fgkTransitHVPolyThick)/2, +// -fgkTransitHVBondingLZ/2, &rotSide); +// TGeoCombiTrans *sideLeftAlTr = 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 *sideLeftTr = new TGeoCombiTrans(0, (fgkWaferThickness+fgkTransitHVPolyThick)/2, - -fgkTransitHVBondingLZ/2, &rotSide); + -fgkTransitHVBondingLZ/2, rotSide); TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0, fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2, - -fgkTransitHVBondingLZ/2, &rotSide); + -fgkTransitHVBondingLZ/2, rotSide); TGeoVolume *vSideLeft = new TGeoVolume("ITSsddHVtransitSideLeft", sideLeft,polyhamideSDD); @@ -2452,29 +5346,38 @@ TGeoVolume* AliITSv11GeometrySDD::CreateSDDsensor() { TGeoVolume *vSideLeftAl = new TGeoVolume("ITSsddHVtransitSideLeftAl", sideLeftAl,alSDD); vSideLeftAl->SetLineColor(fColorAl); - TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight", - sideRight,polyhamideSDD); - vSideRight->SetLineColor(fColorPolyhamide); - virtualSensor->AddNode(vSideLeft, 1, sideLeftTr); - virtualSensor->AddNode(vSideLeftAl, 1, sideLeftAlTr); - virtualSensor->AddNode(vSideRight, 1, sideRightTr); +// 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); + + fSDDsensor4->AddNode(vSideLeft, 1, sideLeftTr); + fSDDsensor4->AddNode(vSideLeftAl, 1, sideLeftAlTr); +// fSDDsensor4->AddNode(vSideRight, 1, sideRightTr); }; //**************************** - if(GetDebug(1)) virtualSensor->CheckOverlaps(0.01); - virtualSensor->SetVisibility(kFALSE); - return virtualSensor; -}; + if(GetDebug(1)) { + fSDDsensor3->CheckOverlaps(0.01); + fSDDsensor4->CheckOverlaps(0.01); + } + fSDDsensor3->SetVisibility(kFALSE); + fSDDsensor4->SetVisibility(kFALSE); +} +/* //________________________________________________________________________ TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) { // // return a box volume containing the detectors // - TGeoMedium *airSDD = GetMedium("ITSair"); + TGeoMedium *airSDD = GetMedium("SDD AIR$"); Int_t nDetectors = fgkLay3Ndet; Double_t ladderLength = fgkLay3LadderLength; @@ -2511,9 +5414,9 @@ TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) { virtualDet->AddNode(fSDDsensor, i, sensorPos); } else { - TGeoRotation rotSensor("",0, 180, 180); + TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180); TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY, - localZ,&rotSensor); + localZ, rotSensor); sensorPos->SetName(name); virtualDet->AddNode(fSDDsensor, i, sensorPos); }; @@ -2522,135 +5425,111 @@ TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) { if(GetDebug(1)) virtualDet->CheckOverlaps(0.01); virtualDet->SetVisibility(kFALSE); return virtualDet; -}; - - +} +*/ //________________________________________________________________________ -Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD, - Int_t startMod) { - // - // export the geometry in a AliITSgeom object - // +TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssembly(Int_t iLay) { +// +// return a box volume containing the detectors +// + + Int_t nDetectors = fgkLay3Ndet; + Double_t ladderLength = fgkLay3LadderLength; + Double_t *sensorZPos = fLay3sensorZPos; + TGeoVolume *sensorSDD = fSDDsensor3; - if (! geom) { - printf("error:Try to fill null (AliITSgeom *) object"); - return kFALSE; - }; - if (! fMotherVol) { - printf("error:Try to set sensor geometry while geometry is not defined\n"); - return kFALSE; + if (iLay==3) {} + else if (iLay==4) { + nDetectors = fgkLay4Ndet; + ladderLength = fgkLay4LadderLength; + sensorZPos = fLay4sensorZPos; + sensorSDD = fSDDsensor4; + } else { + printf("AliITSv11GeometrySDD::CreateDetectorsAssembly: Error:Wrong layer"); }; - const Float_t kDxyz[3] = {fgkWaferWidthSens/2., fgkWaferThickSens/2., - fgkWaferLengthSens/2.}; - if(!(geom->IsShapeDefined(kSDD))) - geom->ReSetShape(kSDD, new AliITSgeomSDD256(3, kDxyz)); - - char layerName[30]; - char ladderName[30]; - char sensorName[30]; - char senstivName[30]; - const Int_t kNLay = 2; - const Int_t kNLadd[kNLay] = {fgkLay3Nladd, fgkLay4Nladd}; - const Int_t kNDet[kNLay] = {fgkLay3Ndet, fgkLay4Ndet}; - - if (GetDebug(1)) - printf("AliITSv11GeometrySDD::SetSensorGeometry(), nodes found :\n"); - - Int_t firstSDDmod = startMod; - for (Int_t iLay=0; iLayGetNode(layerName); - if (layNode) { - if (GetDebug(1)) printf("%s\n",layNode->GetName()); - TGeoVolume *layVolume = layNode->GetVolume(); - TGeoHMatrix layMatrix(*layNode->GetMatrix()); - - for (Int_t iLadd=0; iLaddGetNode(ladderName); - if (laddNode) { - if (GetDebug(1)) printf("| %s\n",laddNode->GetName()); - TGeoVolume *laddVolume = laddNode->GetVolume(); - TGeoHMatrix laddMatrix(layMatrix); - laddMatrix.Multiply(laddNode->GetMatrix()); - - for (Int_t iDet=0; iDetGetNode(sensorName); - if (detNode) { - if (GetDebug(1)) printf("| | %s\n",detNode->GetName()); - TGeoVolume *detVolume = detNode->GetVolume(); - TGeoHMatrix detMatrix(laddMatrix); - detMatrix.Multiply(detNode->GetMatrix()); - - TGeoNode *wafNode = detVolume->GetNode("ITSsddWafer_1"); - if (wafNode) { - TGeoVolume *wafVolume = wafNode->GetVolume(); - TGeoHMatrix wafMatrix(detMatrix); - detMatrix.Multiply(wafNode->GetMatrix()); - //-------------------------------------------------------- - sprintf(senstivName, "%s%s", fgSDDsensitiveVolName,"_1"); - TGeoNode *sensitivNode = wafVolume->GetNode(senstivName); - if (sensitivNode) { - TGeoHMatrix sensMatrix(wafMatrix); - sensMatrix.Multiply(sensitivNode->GetMatrix()); - - // Sticking to the convention for local wafer coordinate - // in AliITSgeom : - if (iDet >= kNDet[iLay]/2) { - // TGeoRotation rotY("",0,180,0); - TGeoRotation rotY("",-180,-180,0); - sensMatrix.Multiply(&rotY); - }; - // Creating the matrix in AliITSgeom for - // this sensitive volume : - Double_t *trans = sensMatrix.GetTranslation(); - Double_t *r = sensMatrix.GetRotationMatrix(); - Double_t rot[10] = {r[0],r[1],r[2], - r[3],r[4],r[5], - r[6],r[7],r[8], 1.0}; - //rot[9]!=0.0 => not a unity matrix - geom->CreatMatrix(startMod,iLay+iLaySDD,iLadd+1,iDet+1, - kSDD,trans,rot); - // iLadd+1, iDet+1 because ladd. and det. start at +1 - // elsewhere - startMod++; - - } else - printf("Error (ExportSensorGeometry) %s not found !\n", - senstivName); - } else - printf("Error (ExportSensorGeometry) %s not found !\n", - "ITSsddWafer_1"); - } else - printf("Error (ExportSensorGeometry) %s not found !\n", - sensorName); - }; - } else - printf("Error (ExportSensorGeometry) %s not found !\n", - ladderName); - }; - } else - printf("Error (ExportSensorGeometry) %s not found !\n", - layerName); - }; + char name[30]; + snprintf(name,30,"ITSsddDetBox%i",iLay); + + TGeoVolumeAssembly *virtualDet = new TGeoVolumeAssembly("ITSsddLadd"); + + for (Int_t i=0; i= nDetectors/2) { + TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ); + sensorPos->SetName(name); + virtualDet->AddNode(sensorSDD, i, sensorPos); + } + else { + TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180); + TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY, + localZ, rotSensor); + sensorPos->SetName(name); + virtualDet->AddNode(sensorSDD, i, sensorPos); + }; + } + + if(GetDebug(1)) virtualDet->CheckOverlaps(0.01); + return virtualDet; +} + + +//________________________________________________________________________ +TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssemblyLadd2() { +// +// return a box volume containing the detectors +// Special case for Layer 3 Ladder 2 which is rotated (cannot simply +// rotate the standard volume, because the module numbering would be wrong) +// M.Sitta 25 Nov 2009 +// + + Int_t nDetectors = fgkLay3Ndet; + Double_t *sensorZPos = fLay3sensorZPos; + TGeoVolume *sensorSDD = fSDDsensor3; + + char name[30]; + snprintf(name,30,"ITSsddDetBoxLadd2"); + + TGeoVolumeAssembly *virtualDet = new TGeoVolumeAssembly("ITSsddLadd"); - return (startMod-firstSDDmod); -}; + for (Int_t i=0; i= nDetectors/2) { + TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ); + sensorPos->SetName(name); + virtualDet->AddNode(sensorSDD, i, sensorPos); + } + else { + TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180); + TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY, + localZ, rotSensor); + sensorPos->SetName(name); + virtualDet->AddNode(sensorSDD, i, sensorPos); + }; + } + + if(GetDebug(1)) virtualDet->CheckOverlaps(0.01); + return virtualDet; +} //________________________________________________________________________ Int_t AliITSv11GeometrySDD:: GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const { - // - // Function which gives the layer, ladder and det. - // index of the current volume. To be used in - // AliITS::StepManager() +// +// Function which gives the layer, ladder and det. +// index of the current volume. To be used in +// AliITS::StepManager() // if (gGeoManager->GetLevel()<3) return kFALSE; @@ -2666,8 +5545,462 @@ GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const { // Get the layer index : if (node->GetNdaughters()==fgkLay3Ndet) - lay = 3; // this has to be equal to the iLaySDD argument given to ExportSensorGeometry() !!! + lay = 3; else lay = 4; 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; iDefineSection(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) const { + // 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 OPTICFIB$"); + + char titleCable[30]; + snprintf(titleCable,30,"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 +// +// Input: +// moth : the TGeoVolume owing the volume structure +// Output: +// +// Created: ??? Ludovic Gaudichet +// Updated: 15 Mar 2008 Mario Sitta +// Updated: 14 Apr 2008 Mario Sitta Overlap fixes +// Updated: 09 May 2008 Mario Sitta SSD overlap fixes +// + + TGeoMedium *copper = GetMedium("COPPER$"); + TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); + TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$"); + 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; + + // Do not use hardcoded numbers, get them from real shapes - M.S. 15/03/08 + TGeoVolume *sddCone = gGeoManager->GetVolume("SDDCarbonFiberCone"); + TGeoPcon *sddConeShape = (TGeoPcon*)sddCone->GetShape(); + + TGeoVolume *sddCylinder = gGeoManager->GetVolume("SDDCarbonFiberCylinder"); + TGeoTube *sddCylinderShape = (TGeoTube*)sddCylinder->GetShape(); + + // (were fgkConeSDDr1, fgkConeSDDr2, fgkConeSDDz1, fgkConeSDDz2 hardcoded) + Double_t coneSDDr1 = sddConeShape->GetRmin(5); + Double_t coneSDDr2 = sddConeShape->GetRmin(3); + + Double_t coneSDDz1 = sddConeShape->GetZ(9) - sddConeShape->GetZ(5) + + sddCylinderShape->GetDz(); + Double_t coneSDDz2 = sddConeShape->GetZ(9) - sddConeShape->GetZ(3) + + sddCylinderShape->GetDz(); + + // Calculate z1, z2 thanks to R1 and R2 + Double_t sddCableZ1 = GetConeZ(fgkSDDCableR1, coneSDDr1, coneSDDr2, + coneSDDz1, coneSDDz2); + Double_t sddCableZ2 = GetConeZ(fgkSDDCableR2, coneSDDr1, coneSDDr2, + coneSDDz1, coneSDDz2); + Double_t sddCableZ3 = GetConeZ(fgkSDDCableR3, coneSDDr1, coneSDDr2, + coneSDDz1, coneSDDz2); + + 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)); + + 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); + + 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, 1); + moth->AddNode(vpcon1container, 2, 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)); + + + 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, 1); + moth->AddNode(vpcon2container, 2, rotCableSDD); + + //================================== + // intermediate cylinder + //================================== + + // (was fgkSDDCableDZint hardcoded) + Double_t sddCableDZint = (sddConeShape->GetZ(9) - sddConeShape->GetZ(0) + + sddCylinderShape->GetDz()) - sddCableZ3; + + TGeoTube *interCyl = new TGeoTube("sddCableInterCyl", + pcon2container->GetRmin(1), + pcon2container->GetRmax(1), + sddCableDZint/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, sddCableDZint/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, sddCableDZint/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, sddCableDZint/2); + + TGeoVolume *vInterCylGlass = new TGeoVolume("vSddCableInterCylGlass", + interCylGlass,opticalFiber); + vInterCylGlass->SetLineColor(kGreen); + vInterCyl->AddNode(vInterCylGlass, 0); + + moth->AddNode(vInterCyl, 1, new TGeoTranslation(0, 0, + sddCableZ3+sddCableDZint/2)); + moth->AddNode(vInterCyl, 2, new TGeoTranslation(0, 0, + -sddCableZ3-sddCableDZint/2)); + + //================================== + // cable cone on the SSD cone + //================================== + + Double_t sddCableR4 = rmaxCylPlast; + Double_t sddCableZ4 = sddCableZ3 + sddCableDZint; + + 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)); + + + 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, 1); + moth->AddNode(vpcon3container, 2, rotCableSDD); + + //================================== + // cables that are grouped at the end of SSD cones + //================================== + +// Double_t fgkSDDCableR6 = fgkSDDCableR5+9; +// Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8.8; + Double_t fgkSDDCableR6 = fgkSDDCableR5+8; + Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8; + + TGeoVolumeAssembly *endConeSDDCable = new TGeoVolumeAssembly("endConeSDDCable"); + + // Add some hardcoded shifts to avoid overlaps with SSD pathc panels + CreateAndInsetConeCablePart(endConeSDDCable, 20, 1*3,2*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6); + + CreateAndInsetConeCablePart(endConeSDDCable, 50, 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, 105, 2*3,3*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6); + + CreateAndInsetConeCablePart(endConeSDDCable, 129, 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, 210, 1*3,2*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6); + + CreateAndInsetConeCablePart(endConeSDDCable, 230, 1*3,2*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6); + + CreateAndInsetConeCablePart(endConeSDDCable, 277, 2*3,2*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6); + + CreateAndInsetConeCablePart(endConeSDDCable, 306, 1*3,1*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6); + + CreateAndInsetConeCablePart(endConeSDDCable, 353, 1*3,3*4, fgkSDDCableR5, + fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6); + + moth->AddNode(endConeSDDCable, 1, 0); + + TGeoRotation* reflect = new TGeoRotation("reflectEndConeSDDCable"); + reflect->ReflectZ(kTRUE); + moth->AddNode(endConeSDDCable, 2, reflect); + + + return; +}