#define SQ(A) (A)*(A)
//______________________________________________________________________
-void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr)
+void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SPD thermal shield as a volume assembly
//
// Created: ??? ???
// Updated: 11 Dec 2007 Mario Sitta
+// Updated: 20 Mar 2012 Mario Sitta Reimplemented with simpler shapes
+// Updated: 20 Jul 2012 Mario Sitta Reimplemented with Composite Shape
+// Updated: 12 Oct 2012 Mario Sitta Composite Shape also for EndCap
//
// Technical data are taken from: ALICE-Thermal Screen "Cone transition"
// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
// Dimensions of the Central shield
- const Double_t kHalfLengthCentral = 400.*fgkmm;
+ const Double_t kHalfLengthCentral = 399.9*fgkmm;
const Double_t kThicknessCentral = 0.4*fgkmm;
const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
const Double_t kInnerBCentral = 2.023 *fgkcm;
const Double_t kOuterACentral = 2.4374*fgkcm;
const Double_t kOuterBCentral = 3.8162*fgkcm;
+ const Double_t kCoolManifHoleWid = 24.0*fgkmm; // TO BE CHECKED!
+ const Double_t kCoolManifHoleLen = 57.5*fgkmm; // 54.2 + 1.5*2 + 0.3 toll.
+ const Double_t kCoolManifHoleZPos = 36.47*fgkcm;// MUST match SPD class
+ const Double_t kCoolSuppHoleWid = 15.0*fgkmm;
+ const Double_t kCoolSuppHoleLen = 38.4*fgkmm; // 35.1 + 1.5*2 + 0.3 toll.// TO BE CHECKED!
+ const Double_t kCoolSuppHoleZPos = 26.5*fgkcm;
// Dimensions of the EndCap shield
const Double_t kHalfLengthEndCap = 25.*fgkmm;
const Double_t kThicknessEndCap = 2.0*fgkmm;
const Double_t kInnerRadialCone = 37.3*fgkcm;
const Double_t kOuterRadialCone = 39.0*fgkcm;
const Double_t kInnerACone = 14.2344*fgkcm;
- // const Double_t kInnerBCone = 9.0915*fgkcm;
+ const Double_t kInnerBCone = 9.0915*fgkcm;
const Double_t kOuterACone = 9.5058*fgkcm;
- // const Double_t kOuterBCone = 14.8831*fgkcm;
+ const Double_t kOuterBCone = 14.8831*fgkcm;
+ // Dimensions of the filler blocks and bars
+ const Double_t kFillerBlockLength = 20.0*fgkmm;
+ const Double_t kFillerBlockHoleR = 2.4*fgkmm;
+ const Double_t kFillerBlockZTrans = 1.5*fgkmm;
+ const Double_t kFillerBarLength = 220.0*fgkmm;
+ const Double_t kFillerBarThick = 1.0*fgkmm;
// Dimensions of the Flange's Ring and Wing
const Double_t kHalfLengthRing = 7.5*fgkmm;
const Double_t kThicknessRing = 0.3*fgkmm;
const Double_t kWideWing = 6.0*fgkcm;
const Double_t kThetaWing = 45.0;
// Common data
- const Double_t kTheta = 36.0*TMath::DegToRad();
+ const Double_t kThetaDeg = 36.0;
+ const Double_t kTheta = kThetaDeg*TMath::DegToRad();
const Double_t kThicknessOmega = 0.3*fgkmm;
// Local variables
- Double_t x, y;
- Double_t xshld[24], yshld[24];
- Double_t xair[24] , yair[24];
+ Double_t xpos, ypos, zpos;
+ Double_t xXtru[24], yXtru[24];
+ Double_t xshld[24], yshld[24]; // Coord. of external thermal shape
+ Double_t xair[24] , yair[24]; // Coord. of whole air shape
Double_t xomega[48], yomega[48];
- // Double_t *xyarb8;
+
// The entire shield is made up of two half central shields
// symmetric with respect to the XZ plane, four half end cap
TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");
- // The central half shield: a half tube of carbon fiber,
- // a similar but proportionally smaller half tube of air inside it,
- // and a Omega-shaped carbon fiber insert inside the air.
- // They are all XTru shapes
-
- TGeoXtru *centralshape = new TGeoXtru(2);
+ // The central half shield: a Composite Shape of carbon fiber.
+ // We need Composite Shapes because we have holes in which the SPD
+ // cooling manifolds and their supports will be placed.
+ // All Composite elements are XTru shapes
+ // First determine the external shape points
CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
kTheta,xshld,yshld);
- centralshape->DefinePolygon(24,xshld,yshld);
- centralshape->DefineSection(0,-kHalfLengthCentral);
- centralshape->DefineSection(1, kHalfLengthCentral);
-
// Now rescale to get the air volume dimensions
InsidePoint(xshld[23], yshld[23],
xshld[ 0], yshld[ 0],
xshld[ 0], yshld[ 0], kThicknessCentral,
xair[23], yair[23]);
- // Create the air shape
- TGeoXtru *centralairshape = new TGeoXtru(2);
-
- centralairshape->DefinePolygon(24,xair,yair);
- centralairshape->DefineSection(0,-kHalfLengthCentral);
- centralairshape->DefineSection(1, kHalfLengthCentral);
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
- // Create the Omega insert
- TGeoXtru *centralomegashape = new TGeoXtru(2);
+ // Finally create the single Xtru volumes
+ TGeoXtru *uppershape = new TGeoXtru(2);
+ uppershape->SetName("upTS");
- CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xair[11-j];
+ yXtru[j ] = yair[11-j];
+ xXtru[j+6] = xshld[j+6];
+ yXtru[j+6] = yshld[j+6];
+ }
+ yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
- centralomegashape->DefinePolygon(48,xomega,yomega);
- centralomegashape->DefineSection(0,-kHalfLengthCentral);
- centralomegashape->DefineSection(1, kHalfLengthCentral);
+ uppershape->DefinePolygon(24,xXtru,yXtru);
+ uppershape->DefineSection(0,-kHalfLengthCentral);
+ uppershape->DefineSection(1, kHalfLengthCentral);
- // The end cap half shield: a half tube of carbon fiber,
- // a similar but proportionally smaller half tube of air inside it,
- // and a Omega-shaped carbon fiber insert inside the air.
- // They are all XTru shapes
+ TGeoXtru *lowershape = new TGeoXtru(2);
+ lowershape->SetName("lwTS");
- TGeoXtru *endcapshape = new TGeoXtru(2);
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xshld[j];
+ yXtru[j ] = yshld[j];
+ xXtru[j+6] = xair[5-j];
+ yXtru[j+6] = yair[5-j];
+ }
+ yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
+ lowershape->DefinePolygon(24,xXtru,yXtru);
+ lowershape->DefineSection(0,-kHalfLengthCentral);
+ lowershape->DefineSection(1, kHalfLengthCentral);
+
+ yomega[10] = yshld[6]; // Add also base thickness
+ yomega[11] = yomega[10];
+ yomega[36] = yshld[17];
+ yomega[37] = yomega[36];
+
+ TGeoXtru *omegashape = new TGeoXtru(2);
+ omegashape->SetName("omTS");
+
+ omegashape->DefinePolygon(48,xomega,yomega);
+ omegashape->DefineSection(0,-kHalfLengthCentral);
+ omegashape->DefineSection(1, kHalfLengthCentral);
+
+ // And now the holes and their position matrices
+ Double_t radius = 0.5*(uppershape->GetY(11)+lowershape->GetY(0));
+
+ TGeoBBox *manifhole = new TGeoBBox(kCoolManifHoleWid/2,
+ 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
+ kCoolManifHoleLen/2);
+ manifhole->SetName("mhTS");
+
+ zpos = kCoolManifHoleZPos;
+
+ TGeoTranslation *m1p = new TGeoTranslation("m1p",0,radius, zpos);
+ TGeoTranslation *m1n = new TGeoTranslation("m1n",0,radius,-zpos);
+ m1p->RegisterYourself();
+ m1n->RegisterYourself();
+
+ TGeoCombiTrans *m2p = new TGeoCombiTrans("m2p",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ TGeoCombiTrans *m2n = new TGeoCombiTrans("m2n",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ m2p->RegisterYourself();
+ m2n->RegisterYourself();
+
+ TGeoCombiTrans *m3p = new TGeoCombiTrans("m3p",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ TGeoCombiTrans *m3n = new TGeoCombiTrans("m3n",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ -zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ m3p->RegisterYourself();
+ m3n->RegisterYourself();
+
+ TGeoCombiTrans *m4p = new TGeoCombiTrans("m4p",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ TGeoCombiTrans *m4n = new TGeoCombiTrans("m4n",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ m4p->RegisterYourself();
+ m4n->RegisterYourself();
+
+ TGeoCombiTrans *m5p = new TGeoCombiTrans("m5p",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ TGeoCombiTrans *m5n = new TGeoCombiTrans("m5n",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ m5p->RegisterYourself();
+ m5n->RegisterYourself();
+
+ TGeoBBox *supphole = new TGeoBBox(kCoolSuppHoleWid/2,
+ 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
+ kCoolSuppHoleLen/2);
+ supphole->SetName("shTS");
+
+ zpos = kCoolSuppHoleZPos;
+
+ TGeoTranslation *s1p = new TGeoTranslation("s1p",0,radius, zpos);
+ TGeoTranslation *s1n = new TGeoTranslation("s1n",0,radius,-zpos);
+ s1p->RegisterYourself();
+ s1n->RegisterYourself();
+
+ TGeoCombiTrans *s2p = new TGeoCombiTrans("s2p",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ TGeoCombiTrans *s2n = new TGeoCombiTrans("s2n",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ s2p->RegisterYourself();
+ s2n->RegisterYourself();
+
+ TGeoCombiTrans *s3p = new TGeoCombiTrans("s3p",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ TGeoCombiTrans *s3n = new TGeoCombiTrans("s3n",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ -zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ s3p->RegisterYourself();
+ s3n->RegisterYourself();
+
+ TGeoCombiTrans *s4p = new TGeoCombiTrans("s4p",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ TGeoCombiTrans *s4n = new TGeoCombiTrans("s4n",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ s4p->RegisterYourself();
+ s4n->RegisterYourself();
+
+ TGeoCombiTrans *s5p = new TGeoCombiTrans("s5p",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ TGeoCombiTrans *s5n = new TGeoCombiTrans("s5n",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ s5p->RegisterYourself();
+ s5n->RegisterYourself();
+
+ // Finally the actual shape
+ TGeoCompositeShape *centralshape = new TGeoCompositeShape("centralTS",
+ "upTS+lwTS+omTS-mhTS:m1p-mhTS:m1n-mhTS:m2p-mhTS:m2n-mhTS:m3p-mhTS:m3n-mhTS:m4p-mhTS:m4n-mhTS:m5p-mhTS:m5n-shTS:s1p-shTS:s1n-shTS:s2p-shTS:s2n-shTS:s3p-shTS:s3n-shTS:s4p-shTS:s4n-shTS:s5p-shTS:s5n");
+
+ // The end cap half shield: a Composite Shape of carbon fiber.
+ // We need Composite Shapes because we have elements partially
+ // entering the empty spaces, and this would create overlaps or
+ // extrusions.
+ // All Composite elements are XTru shapes
+
+ // First determine the external shape points
CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
kTheta,xshld,yshld);
- endcapshape->DefinePolygon(24,xshld,yshld);
- endcapshape->DefineSection(0,-kHalfLengthEndCap);
- endcapshape->DefineSection(1, kHalfLengthEndCap);
-
// Now rescale to get the air volume dimensions
InsidePoint(xshld[23], yshld[23],
xshld[ 0], yshld[ 0],
xshld[ 0], yshld[ 0], kThicknessEndCap,
xair[23], yair[23]);
- // Create the air shape
- TGeoXtru *endcapairshape = new TGeoXtru(2);
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally create the single Xtru volumes
+ TGeoXtru *upendcapshape = new TGeoXtru(2);
+ upendcapshape->SetName("upEC");
+
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xair[11-j];
+ yXtru[j ] = yair[11-j];
+ xXtru[j+6] = xshld[j+6];
+ yXtru[j+6] = yshld[j+6];
+ }
+ yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
- endcapairshape->DefinePolygon(24,xair,yair);
- endcapairshape->DefineSection(0,-kHalfLengthEndCap);
- endcapairshape->DefineSection(1, kHalfLengthEndCap);
+ upendcapshape->DefinePolygon(24,xXtru,yXtru);
+ upendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ upendcapshape->DefineSection(1, kHalfLengthEndCap);
- // Create the Omega insert
- TGeoXtru *endcapomegashape = new TGeoXtru(2);
+ TGeoXtru *lowendcapshape = new TGeoXtru(2);
+ lowendcapshape->SetName("lwEC");
- CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xshld[j];
+ yXtru[j ] = yshld[j];
+ xXtru[j+6] = xair[5-j];
+ yXtru[j+6] = yair[5-j];
+ }
+ yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
- endcapomegashape->DefinePolygon(48,xomega,yomega);
- endcapomegashape->DefineSection(0,-kHalfLengthEndCap);
- endcapomegashape->DefineSection(1, kHalfLengthEndCap);
+ lowendcapshape->DefinePolygon(24,xXtru,yXtru);
+ lowendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ lowendcapshape->DefineSection(1, kHalfLengthEndCap);
- // The cone half shield is more complex since there is no basic
- // TGeo shape to describe it correctly. So it is made of a series
- // of TGeoArb8 shapes filled with air, which all together make up the
- // the cone AND its internal insert. Part of the following code is
- // adapted from SPDThermalSheald method.
+ yomega[10] = yshld[6]; // Add also base thickness
+ yomega[11] = yomega[10];
+ yomega[36] = yshld[17];
+ yomega[37] = yomega[36];
+
+ TGeoXtru *omgendcapshape = new TGeoXtru(2);
+ omgendcapshape->SetName("omEC");
+
+ omgendcapshape->DefinePolygon(48,xomega,yomega);
+ omgendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ omgendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ // Finally the actual shape
+ TGeoCompositeShape *endcapshape = new TGeoCompositeShape("endcapTS",
+ "upEC+lwEC+omEC");
+
+ // The filler block: a Xtru
+ TGeoXtru *fillershape = new TGeoXtru(2);
+
+ xXtru[0] = omgendcapshape->GetX(1) + 0.0002; // Avoid thiny extrusion
+ yXtru[0] = omgendcapshape->GetY(1);
+ xXtru[1] = omgendcapshape->GetX(0) + 0.0002;
+ yXtru[1] = omgendcapshape->GetY(0);
+ xXtru[2] = omgendcapshape->GetX(47) - 0.0002;
+ yXtru[2] = omgendcapshape->GetY(47);
+ xXtru[3] = omgendcapshape->GetX(46);
+ yXtru[3] = omgendcapshape->GetY(46);
+
+ fillershape->DefinePolygon(4,xXtru,yXtru);
+ fillershape->DefineSection(0,-kFillerBlockLength/2);
+ fillershape->DefineSection(1, kFillerBlockLength/2);
+
+ // The hole in the filler: a Tube (made of air)
+ TGeoTube *fillerholeshape = new TGeoTube(0, kFillerBlockHoleR,
+ kFillerBlockLength/2);
+
+ // The filler bar: a BBox
+ Double_t fside = omgendcapshape->GetY(14) - omgendcapshape->GetY(13);
+ TGeoBBox *fillbarshape = new TGeoBBox(fside/2, fside/2, kFillerBarLength/2);
- // Filled portions
- TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
- TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
+ // The hole in the bar filler: a smaller BBox (made of air)
+ fside -= 2*kFillerBarThick;
+ TGeoBBox *fillbarholeshape = new TGeoBBox(fside/2, fside/2,
+ kFillerBarLength/2);
+ // The cone half shield is more complex since there is no basic
+ // TGeo shape to describe it correctly. So it is a Composite Shape
+ // of a series of TGeoArb8 shapes, in which TGeoArb8 shapes filled
+ // with air are placed, which all together make up the cone AND
+ // its internal insert. Part of the following code is adapted from
+ // old SPDThermalSheald method.
+
+ // sCn : Filled portions, sChn : Air holes
+ TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC3 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC4 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC5 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC6 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC7 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC8 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC9 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone);
+
+ sC1->SetName("sC1");
+ sC2->SetName("sC2");
+ sC3->SetName("sC3");
+ sC4->SetName("sC4");
+ sC5->SetName("sC5");
+ sC6->SetName("sC6");
+ sC7->SetName("sC7");
+ sC8->SetName("sC8");
+ sC9->SetName("sC9");
+ sC10->SetName("sC10");
+ sC11->SetName("sC11");
+
+ TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh3 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh4 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh5 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh6 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh7 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh8 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh9 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone);
+
+ sCh1->SetName("sCh1");
+ sCh2->SetName("sCh2");
+ sCh3->SetName("sCh3");
+ sCh4->SetName("sCh4");
+ sCh5->SetName("sCh5");
+ sCh6->SetName("sCh6");
+ sCh7->SetName("sCh7");
+ sCh8->SetName("sCh8");
+ sCh9->SetName("sCh9");
+ sCh10->SetName("sCh10");
+ sCh11->SetName("sCh11");
+
+ // Smaller end: determine the coordinates of the points of carbon fiber
CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
kTheta,xshld,yshld);
- sC1->SetVertex(0,xshld[12],yshld[12]);
- sC1->SetVertex(1,xshld[11],yshld[11]);
- sC1->SetVertex(2,xshld[ 0],yshld[ 0]);
- sC1->SetVertex(3,xshld[23],yshld[23]);
+ sC1->SetVertex(0, xshld[12], yshld[12]);
+ sC1->SetVertex(1, xshld[11], yshld[11]);
+ sC1->SetVertex(2, xshld[ 0], yshld[ 0]);
+ sC1->SetVertex(3, xshld[23], yshld[23]);
+
+ sC2->SetVertex(0, xshld[11], yshld[11]);
+ sC2->SetVertex(1, xshld[10], yshld[10]);
+ sC2->SetVertex(2, xshld[ 1], yshld[ 1]);
+ sC2->SetVertex(3, xshld[ 0], yshld[ 0]);
+
+ sC3->SetVertex(0, xshld[10], yshld[10]);
+ sC3->SetVertex(1, xshld[ 9], yshld[ 9]);
+ sC3->SetVertex(2, xshld[ 2], yshld[ 2]);
+ sC3->SetVertex(3, xshld[ 1], yshld[ 1]);
+
+ sC4->SetVertex(0, xshld[ 9], yshld[ 9]);
+ sC4->SetVertex(1, xshld[ 8], yshld[ 8]);
+ sC4->SetVertex(2, xshld[ 3], yshld[ 3]);
+ sC4->SetVertex(3, xshld[ 2], yshld[ 2]);
+
+ sC5->SetVertex(0, xshld[ 8], yshld[ 8]);
+ sC5->SetVertex(1, xshld[ 7], yshld[ 7]);
+ sC5->SetVertex(2, xshld[ 4], yshld[ 4]);
+ sC5->SetVertex(3, xshld[ 3], yshld[ 3]);
+
+ sC6->SetVertex(0, xshld[ 7], yshld[ 7]);
+ sC6->SetVertex(1, xshld[ 6], yshld[ 6]);
+ sC6->SetVertex(2, xshld[ 5], yshld[ 5]);
+ sC6->SetVertex(3, xshld[ 4], yshld[ 4]);
+
+ sC7->SetVertex(0,-xshld[10], yshld[10]);
+ sC7->SetVertex(1,-xshld[11], yshld[11]);
+ sC7->SetVertex(2,-xshld[ 0], yshld[ 0]);
+ sC7->SetVertex(3,-xshld[ 1], yshld[ 1]);
+
+ sC8->SetVertex(0,-xshld[ 9], yshld[ 9]);
+ sC8->SetVertex(1,-xshld[10], yshld[10]);
+ sC8->SetVertex(2,-xshld[ 1], yshld[ 1]);
+ sC8->SetVertex(3,-xshld[ 2], yshld[ 2]);
+
+ sC9->SetVertex(0,-xshld[ 8], yshld[ 8]);
+ sC9->SetVertex(1,-xshld[ 9], yshld[ 9]);
+ sC9->SetVertex(2,-xshld[ 2], yshld[ 2]);
+ sC9->SetVertex(3,-xshld[ 3], yshld[ 3]);
+
+ sC10->SetVertex(0,-xshld[ 7], yshld[ 7]);
+ sC10->SetVertex(1,-xshld[ 8], yshld[ 8]);
+ sC10->SetVertex(2,-xshld[ 3], yshld[ 3]);
+ sC10->SetVertex(3,-xshld[ 4], yshld[ 4]);
+
+ sC11->SetVertex(0,-xshld[ 6], yshld[ 6]);
+ sC11->SetVertex(1,-xshld[ 7], yshld[ 7]);
+ sC11->SetVertex(2,-xshld[ 4], yshld[ 4]);
+ sC11->SetVertex(3,-xshld[ 5], yshld[ 5]);
+
+ // Then rescale to get the air volume dimensions
+ InsidePoint(xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0],
+ xshld[ 1], yshld[ 1], kThicknessCone,
+ xair[0], yair[0]);
+ for (Int_t i=1; i<23; i++) {
+ InsidePoint(xshld[i-1], yshld[i-1],
+ xshld[ i ], yshld[ i ],
+ xshld[i+1], yshld[i+1], kThicknessCone,
+ xair[i], yair[i]);
+ }
+ InsidePoint(xshld[22], yshld[22],
+ xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0], kThicknessCone,
+ xair[23], yair[23]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
- sC2->SetVertex(0,xshld[11],yshld[11]);
- sC2->SetVertex(1,xshld[10],yshld[10]);
- sC2->SetVertex(2,xshld[ 1],yshld[ 1]);
- sC2->SetVertex(3,xshld[ 0],yshld[ 0]);
+ // Finally fill the small end coordinates of the air shapes
+ sCh1->SetVertex(0, xomega[ 0], yomega[ 0]);
+ sCh1->SetVertex(1, xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]);
+
+ sCh2->SetVertex(0, xomega[20], yomega[20]);
+ sCh2->SetVertex(1, xomega[21], yomega[21]);
+ sCh2->SetVertex(2, xomega[22], yomega[22]);
+ sCh2->SetVertex(3, xomega[23], yomega[23]);
+
+ sCh3->SetVertex(0, xomega[ 2], yomega[ 2]);
+ sCh3->SetVertex(1, xomega[ 3], yomega[ 3]);
+ sCh3->SetVertex(2, xomega[ 4], yomega[ 4]);
+ sCh3->SetVertex(3, xomega[ 5], yomega[ 5]);
+
+ sCh4->SetVertex(0, xomega[16], yomega[16]);
+ sCh4->SetVertex(1, xomega[17], yomega[17]);
+ sCh4->SetVertex(2, xomega[18], yomega[18]);
+ sCh4->SetVertex(3, xomega[19], yomega[19]);
+
+ sCh5->SetVertex(0, xomega[ 6], yomega[ 6]);
+ sCh5->SetVertex(1, xomega[ 7], yomega[ 7]);
+ sCh5->SetVertex(2, xomega[ 8], yomega[ 8]);
+ sCh5->SetVertex(3, xomega[ 9], yomega[ 9]);
+
+ sCh6->SetVertex(0, xomega[12], yomega[12]);
+ sCh6->SetVertex(1, xomega[13], yomega[13]);
+ sCh6->SetVertex(2, xomega[14], yomega[14]);
+ sCh6->SetVertex(3, xomega[15], yomega[15]);
+
+ sCh7->SetVertex(0,-xomega[21], yomega[21]);
+ sCh7->SetVertex(1,-xomega[20], yomega[20]);
+ sCh7->SetVertex(2,-xomega[23], yomega[23]);
+ sCh7->SetVertex(3,-xomega[22], yomega[22]);
+
+ sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]);
+ sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]);
+ sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]);
+ sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]);
+
+ sCh9->SetVertex(0,-xomega[17], yomega[17]);
+ sCh9->SetVertex(1,-xomega[16], yomega[16]);
+ sCh9->SetVertex(2,-xomega[19], yomega[19]);
+ sCh9->SetVertex(3,-xomega[18], yomega[18]);
+
+ sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]);
+ sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]);
+ sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]);
+ sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]);
+
+ sCh11->SetVertex(0,-xomega[13], yomega[13]);
+ sCh11->SetVertex(1,-xomega[12], yomega[12]);
+ sCh11->SetVertex(2,-xomega[15], yomega[15]);
+ sCh11->SetVertex(3,-xomega[14], yomega[14]);
+
+ // Bigger end: determine the coordinates of the points of carbon fiber
// Drawings give only the radius, convert it to the apothegm
Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
- 0.25*kOuterACone*kOuterACone);
- Double_t xco[4], yco[4], xci[4], yci[4];
-
- for (Int_t i=0; i<2; i++) {
- Double_t th = i*kTheta*TMath::RadToDeg();
- xco[2*i ] = kOuterRadiusCone*SinD(th) - 0.5*kOuterACone*CosD(th);
- yco[2*i ] = kOuterRadiusCone*CosD(th) + 0.5*kOuterACone*SinD(th);
- xci[2*i ] = kInnerRadiusCone*SinD(th) - 0.5*kInnerACone*CosD(th);
- yci[2*i ] = kInnerRadiusCone*CosD(th) + 0.5*kInnerACone*SinD(th);
- xco[2*i+1] = kOuterRadiusCone*SinD(th) + 0.5*kOuterACone*CosD(th);
- yco[2*i+1] = kOuterRadiusCone*CosD(th) - 0.5*kOuterACone*SinD(th);
- xci[2*i+1] = kInnerRadiusCone*SinD(th) + 0.5*kInnerACone*CosD(th);
- yci[2*i+1] = kInnerRadiusCone*CosD(th) - 0.5*kInnerACone*SinD(th);
- }
+ CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
+ kOuterACone,kOuterBCone,kOuterRadiusCone,
+ kTheta,xshld,yshld);
- sC1->SetVertex(4,xco[0],yco[0]);
- sC1->SetVertex(5,xco[1],yco[1]);
- sC1->SetVertex(6,xci[1],yci[1]);
- sC1->SetVertex(7,xci[0],yci[0]);
-
- sC2->SetVertex(4,xco[1],yco[1]);
- sC2->SetVertex(5,xco[2],yco[2]);
- sC2->SetVertex(6,xci[2],yci[2]);
- sC2->SetVertex(7,xci[1],yci[1]);
-
- // Air holes
- TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
- TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
-
- for(Int_t i=0; i<4; i++){
- InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0],
- sC1->GetVertices()[((i+3)%4)*2+1],
- sC1->GetVertices()[i*2+0],
- sC1->GetVertices()[i*2+1],
- sC1->GetVertices()[((i+1)%4)*2+0],
- sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
- sCh1->SetVertex(i,x,y);
-
- InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0],
- sC1->GetVertices()[((i+3)%4 +4)*2+1],
- sC1->GetVertices()[(i+4)*2+0],
- sC1->GetVertices()[(i+4)*2+1],
- sC1->GetVertices()[((i+1)%4 +4)*2+0],
- sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
- sCh1->SetVertex(i+4,x,y);
-
- InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0],
- sC2->GetVertices()[((i+3)%4)*2+1],
- sC2->GetVertices()[i*2+0],
- sC2->GetVertices()[i*2+1],
- sC2->GetVertices()[((i+1)%4)*2+0],
- sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
- sCh2->SetVertex(i,x,y);
-
- InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0],
- sC2->GetVertices()[((i+3)%4 +4)*2+1],
- sC2->GetVertices()[(i+4)*2+0],
- sC2->GetVertices()[(i+4)*2+1],
- sC2->GetVertices()[((i+1)%4 +4)*2+0],
- sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
- sCh2->SetVertex(i+4,x,y);
+ sC1->SetVertex(4, xshld[12], yshld[12]);
+ sC1->SetVertex(5, xshld[11], yshld[11]);
+ sC1->SetVertex(6, xshld[ 0], yshld[ 0]);
+ sC1->SetVertex(7, xshld[23], yshld[23]);
+
+ sC2->SetVertex(4, xshld[11], yshld[11]);
+ sC2->SetVertex(5, xshld[10], yshld[10]);
+ sC2->SetVertex(6, xshld[ 1], yshld[ 1]);
+ sC2->SetVertex(7, xshld[ 0], yshld[ 0]);
+
+ sC3->SetVertex(4, xshld[10], yshld[10]);
+ sC3->SetVertex(5, xshld[ 9], yshld[ 9]);
+ sC3->SetVertex(6, xshld[ 2], yshld[ 2]);
+ sC3->SetVertex(7, xshld[ 1], yshld[ 1]);
+
+ sC4->SetVertex(4, xshld[ 9], yshld[ 9]);
+ sC4->SetVertex(5, xshld[ 8], yshld[ 8]);
+ sC4->SetVertex(6, xshld[ 3], yshld[ 3]);
+ sC4->SetVertex(7, xshld[ 2], yshld[ 2]);
+
+ sC5->SetVertex(4, xshld[ 8], yshld[ 8]);
+ sC5->SetVertex(5, xshld[ 7], yshld[ 7]);
+ sC5->SetVertex(6, xshld[ 4], yshld[ 4]);
+ sC5->SetVertex(7, xshld[ 3], yshld[ 3]);
+
+ sC6->SetVertex(4, xshld[ 7], yshld[ 7]);
+ sC6->SetVertex(5, xshld[ 6], yshld[ 6]);
+ sC6->SetVertex(6, xshld[ 5], yshld[ 5]);
+ sC6->SetVertex(7, xshld[ 4], yshld[ 4]);
+
+ sC7->SetVertex(4,-xshld[10], yshld[10]);
+ sC7->SetVertex(5,-xshld[11], yshld[11]);
+ sC7->SetVertex(6,-xshld[ 0], yshld[ 0]);
+ sC7->SetVertex(7,-xshld[ 1], yshld[ 1]);
+
+ sC8->SetVertex(4,-xshld[ 9], yshld[ 9]);
+ sC8->SetVertex(5,-xshld[10], yshld[10]);
+ sC8->SetVertex(6,-xshld[ 1], yshld[ 1]);
+ sC8->SetVertex(7,-xshld[ 2], yshld[ 2]);
+
+ sC9->SetVertex(4,-xshld[ 8], yshld[ 8]);
+ sC9->SetVertex(5,-xshld[ 9], yshld[ 9]);
+ sC9->SetVertex(6,-xshld[ 2], yshld[ 2]);
+ sC9->SetVertex(7,-xshld[ 3], yshld[ 3]);
+
+ sC10->SetVertex(4,-xshld[ 7], yshld[ 7]);
+ sC10->SetVertex(5,-xshld[ 8], yshld[ 8]);
+ sC10->SetVertex(6,-xshld[ 3], yshld[ 3]);
+ sC10->SetVertex(7,-xshld[ 4], yshld[ 4]);
+
+ sC11->SetVertex(4,-xshld[ 6], yshld[ 6]);
+ sC11->SetVertex(5,-xshld[ 7], yshld[ 7]);
+ sC11->SetVertex(6,-xshld[ 4], yshld[ 4]);
+ sC11->SetVertex(7,-xshld[ 5], yshld[ 5]);
+
+ // Then rescale to get the air volume dimensions
+ InsidePoint(xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0],
+ xshld[ 1], yshld[ 1], kThicknessCone,
+ xair[0], yair[0]);
+ for (Int_t i=1; i<23; i++) {
+ InsidePoint(xshld[i-1], yshld[i-1],
+ xshld[ i ], yshld[ i ],
+ xshld[i+1], yshld[i+1], kThicknessCone,
+ xair[i], yair[i]);
}
+ InsidePoint(xshld[22], yshld[22],
+ xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0], kThicknessCone,
+ xair[23], yair[23]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally fill the big end coordinates of the air shapes
+ sCh1->SetVertex(4, xomega[ 0], yomega[ 0]);
+ sCh1->SetVertex(5, xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]);
+
+ sCh2->SetVertex(4, xomega[20], yomega[20]);
+ sCh2->SetVertex(5, xomega[21], yomega[21]);
+ sCh2->SetVertex(6, xomega[22], yomega[22]);
+ sCh2->SetVertex(7, xomega[23], yomega[23]);
+
+ sCh3->SetVertex(4, xomega[ 2], yomega[ 2]);
+ sCh3->SetVertex(5, xomega[ 3], yomega[ 3]);
+ sCh3->SetVertex(6, xomega[ 4], yomega[ 4]);
+ sCh3->SetVertex(7, xomega[ 5], yomega[ 5]);
+
+ sCh4->SetVertex(4, xomega[16], yomega[16]);
+ sCh4->SetVertex(5, xomega[17], yomega[17]);
+ sCh4->SetVertex(6, xomega[18], yomega[18]);
+ sCh4->SetVertex(7, xomega[19], yomega[19]);
+
+ sCh5->SetVertex(4, xomega[ 6], yomega[ 6]);
+ sCh5->SetVertex(5, xomega[ 7], yomega[ 7]);
+ sCh5->SetVertex(6, xomega[ 8], yomega[ 8]);
+ sCh5->SetVertex(7, xomega[ 9], yomega[ 9]);
+
+ sCh6->SetVertex(4, xomega[12], yomega[12]);
+ sCh6->SetVertex(5, xomega[13], yomega[13]);
+ sCh6->SetVertex(6, xomega[14], yomega[14]);
+ sCh6->SetVertex(7, xomega[15], yomega[15]);
+
+ sCh7->SetVertex(4,-xomega[21], yomega[21]);
+ sCh7->SetVertex(5,-xomega[20], yomega[20]);
+ sCh7->SetVertex(6,-xomega[23], yomega[23]);
+ sCh7->SetVertex(7,-xomega[22], yomega[22]);
+
+ sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]);
+ sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]);
+ sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]);
+ sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]);
+
+ sCh9->SetVertex(4,-xomega[17], yomega[17]);
+ sCh9->SetVertex(5,-xomega[16], yomega[16]);
+ sCh9->SetVertex(6,-xomega[19], yomega[19]);
+ sCh9->SetVertex(7,-xomega[18], yomega[18]);
+
+ sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]);
+ sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]);
+ sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]);
+ sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]);
+
+ sCh11->SetVertex(4,-xomega[13], yomega[13]);
+ sCh11->SetVertex(5,-xomega[12], yomega[12]);
+ sCh11->SetVertex(6,-xomega[15], yomega[15]);
+ sCh11->SetVertex(7,-xomega[14], yomega[14]);
+
+ // Now the actual carbon fiber cone: a CompositeShape
+ TGeoCompositeShape *sCone = new TGeoCompositeShape("sCone",
+ "sC1+sC2+sC3+sC4+sC5+sC6+sC7+sC8+sC9+sC10+sC11");
// Finally the carbon fiber Ring with its Wings and their
// stesalite inserts. They are Tube and TubeSeg shapes
centralshield->SetVisibility(kTRUE);
centralshield->SetLineColor(7);
centralshield->SetLineWidth(1);
-
- TGeoVolume *centralairshield = new TGeoVolume("SPDcentralairshield",
- centralairshape,medSPDair);
- centralairshield->SetVisibility(kTRUE);
- centralairshield->SetLineColor(5); // Yellow
- centralairshield->SetLineWidth(1);
- centralairshield->SetFillColor(centralairshield->GetLineColor());
- centralairshield->SetFillStyle(4090); // 90% transparent
-
- TGeoVolume *centralomega = new TGeoVolume("SPDcentralomega",
- centralomegashape,medSPDcf);
- centralomega->SetVisibility(kTRUE);
- centralomega->SetLineColor(7);
- centralomega->SetLineWidth(1);
-
- centralairshield->AddNode(centralomega,1,0);
- centralshield->AddNode(centralairshield,1,0);
+ centralshield->SetFillColor(centralshield->GetLineColor());
+ centralshield->SetFillStyle(4090); // 90% transparent
TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
endcapshape,medSPDcf);
endcapshield->SetVisibility(kTRUE);
endcapshield->SetLineColor(7);
endcapshield->SetLineWidth(1);
-
- TGeoVolume *endcapairshield = new TGeoVolume("SPDendcapairshield",
- endcapairshape,medSPDair);
- endcapairshield->SetVisibility(kTRUE);
- endcapairshield->SetLineColor(5); // Yellow
- endcapairshield->SetLineWidth(1);
- endcapairshield->SetFillColor(endcapairshield->GetLineColor());
- endcapairshield->SetFillStyle(4090); // 90% transparent
-
- TGeoVolume *endcapomega = new TGeoVolume("SPDendcapomega",
- endcapomegashape,medSPDcf);
- endcapomega->SetVisibility(kTRUE);
- endcapomega->SetLineColor(7);
- endcapomega->SetLineWidth(1);
-
- endcapairshield->AddNode(endcapomega,1,0);
- endcapshield->AddNode(endcapairshield,1,0);
-
- TGeoVolume *vC1 = new TGeoVolume("SPDconeshieldV1",sC1,medSPDcf);
- vC1->SetVisibility(kTRUE);
- vC1->SetLineColor(7);
- vC1->SetLineWidth(1);
+ endcapshield->SetFillColor(endcapshield->GetLineColor());
+ endcapshield->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillerblock = new TGeoVolume("SPDfillerblock",
+ fillershape,medSPDcf);
+ fillerblock->SetVisibility(kTRUE);
+ fillerblock->SetLineColor(7);
+ fillerblock->SetLineWidth(1);
+ fillerblock->SetFillColor(fillerblock->GetLineColor());
+ fillerblock->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillerhole = new TGeoVolume("SPDfillerhole",
+ fillerholeshape,medSPDair);
+ fillerhole->SetVisibility(kTRUE);
+ fillerhole->SetLineColor(5); // Yellow
+ fillerhole->SetLineWidth(1);
+ fillerhole->SetFillColor(fillerhole->GetLineColor());
+ fillerhole->SetFillStyle(4090); // 90% transparent
+
+ ypos = (fillershape->GetY(0)+fillershape->GetY(1))/2;
+ fillerblock->AddNode(fillerhole, 1, new TGeoTranslation(0, ypos, 0));
+
+ zpos = omgendcapshape->GetZ(1) - fillershape->GetZ(1) - kFillerBlockZTrans;
+ endcapshield->AddNode(fillerblock, 1, new TGeoTranslation(0, 0, zpos));
+ endcapshield->AddNode(fillerblock, 2, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("", kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 3, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("",-kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 4, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("", 2*kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 5, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0)));
+
+ TGeoVolume *fillerbar = new TGeoVolume("SPDfillerbar",
+ fillbarshape,medSPDcf);
+ fillerbar->SetVisibility(kTRUE);
+ fillerbar->SetLineColor(7);
+ fillerbar->SetLineWidth(1);
+ fillerbar->SetFillColor(fillerbar->GetLineColor());
+ fillerbar->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillbarhole = new TGeoVolume("SPDfillerbarhole",
+ fillbarholeshape,medSPDair);
+ fillbarhole->SetVisibility(kTRUE);
+ fillbarhole->SetLineColor(5); // Yellow
+ fillbarhole->SetLineWidth(1);
+ fillbarhole->SetFillColor(fillbarhole->GetLineColor());
+ fillbarhole->SetFillStyle(4090); // 90% transparent
+
+ fillerbar->AddNode(fillbarhole, 1, 0);
+
+ TGeoVolume *vCone = new TGeoVolume("SPDconeshield",sCone,medSPDcf);
+ vCone->SetVisibility(kTRUE);
+ vCone->SetLineColor(7);
+ vCone->SetLineWidth(1);
+ vCone->SetFillColor(vCone->GetLineColor());
+ vCone->SetFillStyle(4090); // 90% transparent
TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
-
vCh1->SetVisibility(kTRUE);
vCh1->SetLineColor(5); // Yellow
vCh1->SetLineWidth(1);
vCh1->SetFillColor(vCh1->GetLineColor());
vCh1->SetFillStyle(4090); // 90% transparent
- vC1->AddNode(vCh1,1,0);
-
- TGeoVolume *vC2 = new TGeoVolume("SPDconeshieldV2",sC2,medSPDcf);
-
- vC2->SetVisibility(kTRUE);
- vC2->SetLineColor(7);
- vC2->SetLineWidth(1);
-
TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
-
vCh2->SetVisibility(kTRUE);
vCh2->SetLineColor(5); // Yellow
vCh2->SetLineWidth(1);
vCh2->SetFillColor(vCh2->GetLineColor());
vCh2->SetFillStyle(4090); // 90% transparent
- vC2->AddNode(vCh2,1,0);
+ TGeoVolume *vCh3 = new TGeoVolume("SPDconeshieldH3",sCh3,medSPDair);
+ vCh3->SetVisibility(kTRUE);
+ vCh3->SetLineColor(5); // Yellow
+ vCh3->SetLineWidth(1);
+ vCh3->SetFillColor(vCh3->GetLineColor());
+ vCh3->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh4 = new TGeoVolume("SPDconeshieldH4",sCh4,medSPDair);
+ vCh4->SetVisibility(kTRUE);
+ vCh4->SetLineColor(5); // Yellow
+ vCh4->SetLineWidth(1);
+ vCh4->SetFillColor(vCh4->GetLineColor());
+ vCh4->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh5 = new TGeoVolume("SPDconeshieldH5",sCh5,medSPDair);
+ vCh5->SetVisibility(kTRUE);
+ vCh5->SetLineColor(5); // Yellow
+ vCh5->SetLineWidth(1);
+ vCh5->SetFillColor(vCh5->GetLineColor());
+ vCh5->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh6 = new TGeoVolume("SPDconeshieldH6",sCh6,medSPDair);
+ vCh6->SetVisibility(kTRUE);
+ vCh6->SetLineColor(5); // Yellow
+ vCh6->SetLineWidth(1);
+ vCh6->SetFillColor(vCh6->GetLineColor());
+ vCh6->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh7 = new TGeoVolume("SPDconeshieldH7",sCh7,medSPDair);
+ vCh7->SetVisibility(kTRUE);
+ vCh7->SetLineColor(5); // Yellow
+ vCh7->SetLineWidth(1);
+ vCh7->SetFillColor(vCh7->GetLineColor());
+ vCh7->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh8 = new TGeoVolume("SPDconeshieldH8",sCh8,medSPDair);
+ vCh8->SetVisibility(kTRUE);
+ vCh8->SetLineColor(5); // Yellow
+ vCh8->SetLineWidth(1);
+ vCh8->SetFillColor(vCh8->GetLineColor());
+ vCh8->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh9 = new TGeoVolume("SPDconeshieldH9",sCh9,medSPDair);
+ vCh9->SetVisibility(kTRUE);
+ vCh9->SetLineColor(5); // Yellow
+ vCh9->SetLineWidth(1);
+ vCh9->SetFillColor(vCh9->GetLineColor());
+ vCh9->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh10 = new TGeoVolume("SPDconeshieldH10",sCh10,medSPDair);
+ vCh10->SetVisibility(kTRUE);
+ vCh10->SetLineColor(5); // Yellow
+ vCh10->SetLineWidth(1);
+ vCh10->SetFillColor(vCh10->GetLineColor());
+ vCh10->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh11 = new TGeoVolume("SPDconeshieldH11",sCh11,medSPDair);
+ vCh11->SetVisibility(kTRUE);
+ vCh11->SetLineColor(5); // Yellow
+ vCh11->SetLineWidth(1);
+ vCh11->SetFillColor(vCh11->GetLineColor());
+ vCh11->SetFillStyle(4090); // 90% transparent
+
+ vCone->AddNode(vCh1 ,1,0);
+ vCone->AddNode(vCh2 ,1,0);
+ vCone->AddNode(vCh3 ,1,0);
+ vCone->AddNode(vCh4 ,1,0);
+ vCone->AddNode(vCh5 ,1,0);
+ vCone->AddNode(vCh6 ,1,0);
+ vCone->AddNode(vCh7 ,1,0);
+ vCone->AddNode(vCh8 ,1,0);
+ vCone->AddNode(vCh9 ,1,0);
+ vCone->AddNode(vCh10,1,0);
+ vCone->AddNode(vCh11,1,0);
TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
ring->SetVisibility(kTRUE);
wing->SetLineColor(7);
wing->SetLineWidth(1);
- TGeoVolume *winginsert = new TGeoVolume("SPDshieldringinsert",
+ TGeoVolume *winginsert = new TGeoVolume("SPDshieldwinginsert",
winginsertshape,medSPDste);
winginsert->SetVisibility(kTRUE);
winginsert->SetLineColor(3); // Green
// Add all volumes in the assembly
- vM->AddNode(centralshield,1,0);
- vM->AddNode(centralshield,2,new TGeoRotation("",180,0,0));
+ const Double_t kLittleZTrans = 0.1*fgkmm;
+ vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans));
+ vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans,
+ new TGeoRotation("",180,0,0)));
+ zpos = kHalfLengthCentral+kHalfLengthEndCap;
vM->AddNode(endcapshield,1,
- new TGeoTranslation(0,0, kHalfLengthCentral+kHalfLengthEndCap));
- vM->AddNode(endcapshield,2,
- new TGeoTranslation(0,0,-kHalfLengthCentral-kHalfLengthEndCap));
+ new TGeoTranslation(0,0, zpos-kLittleZTrans));
+ vM->AddNode(endcapshield,2,new TGeoCombiTrans(
+ 0, 0,-zpos-kLittleZTrans, new TGeoRotation("", 0,180,0) ) );
vM->AddNode(endcapshield,3,new TGeoCombiTrans(
- 0, 0, kHalfLengthCentral+kHalfLengthEndCap,
- new TGeoRotation("",180,0,0) ) );
+ 0, 0, zpos-kLittleZTrans, new TGeoRotation("",180, 0,0) ) );
vM->AddNode(endcapshield,4,new TGeoCombiTrans(
- 0, 0,-kHalfLengthCentral-kHalfLengthEndCap,
- new TGeoRotation("",180,0,0) ) );
-
- for (Int_t i=0; i<10; i++) {
- Double_t thetaC12 = kTheta*TMath::RadToDeg();
- vM->AddNode(vC1,2*i+1, new TGeoCombiTrans(
- 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
- new TGeoRotation("",0, 0,i*thetaC12) ) );
- vM->AddNode(vC1,2*i+2, new TGeoCombiTrans(
- 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
- new TGeoRotation("",0,180,i*thetaC12) ) );
- vM->AddNode(vC2,2*i+1, new TGeoCombiTrans(
- 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
- new TGeoRotation("",0, 0,i*thetaC12) ) );
- vM->AddNode(vC2,2*i+2, new TGeoCombiTrans(
- 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
- new TGeoRotation("",0,180,i*thetaC12) ) );
- }
+ 0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,180,0) ) );
+
+ xpos = omgendcapshape->GetX(13) + fillbarshape->GetDX();
+ ypos = omgendcapshape->GetY(13) + fillbarshape->GetDY();
+ zpos -= fillbarshape->GetDZ();
+ vM->AddNode(fillerbar, 1, new TGeoTranslation( xpos, ypos, zpos));
+ vM->AddNode(fillerbar, 2, new TGeoTranslation(-xpos, ypos, zpos));
+ vM->AddNode(fillerbar, 3, new TGeoTranslation( xpos,-ypos, zpos));
+ vM->AddNode(fillerbar, 4, new TGeoTranslation(-xpos,-ypos, zpos));
+ vM->AddNode(fillerbar, 5, new TGeoTranslation( xpos, ypos,-zpos));
+ vM->AddNode(fillerbar, 6, new TGeoTranslation(-xpos, ypos,-zpos));
+ vM->AddNode(fillerbar, 7, new TGeoTranslation( xpos,-ypos,-zpos));
+ vM->AddNode(fillerbar, 8, new TGeoTranslation(-xpos,-ypos,-zpos));
+
+ zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone;
+ vM->AddNode(vCone ,1, new TGeoTranslation(0, 0, zpos-kLittleZTrans));
- vM->AddNode(ring,1,new TGeoTranslation(0, 0,
- kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
- +kHalfLengthRing));
- vM->AddNode(ring,2,new TGeoTranslation(0, 0,
- -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
- -kHalfLengthRing));
+ vM->AddNode(vCone ,2, new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 0, 180) ));
+
+ vM->AddNode(vCone ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 180, 0) ));
+
+ vM->AddNode(vCone ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 180, 180) ));
+
+ zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
+ + kHalfLengthRing;
+ vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
+ vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));
for (Int_t i=0; i<4; i++) {
Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
- vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
- kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
- +kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
- vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,
- -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
- -kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
+ vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
+ vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
}
// Some debugging if requested
void AliITSv11GeometrySupport::CreateSPDThermalShape(
Double_t ina, Double_t inb, Double_t inr,
Double_t oua, Double_t oub, Double_t our,
- Double_t t, Double_t *x , Double_t *y )
+ Double_t t, Double_t *x , Double_t *y ) const
{
//
// Creates the proper sequence of X and Y coordinates to determine
//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSPDOmegaShape(
- Double_t *xin, Double_t *yin, Double_t d,
- Double_t *x, Double_t *y)
+ const Double_t *xin, const Double_t *yin, Double_t d,
+ Double_t *x, Double_t *y)
{
//
// Creates the proper sequence of X and Y coordinates to determine
//______________________________________________________________________
void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
Double_t r, Double_t t,
- Double_t *x, Double_t *y)
+ Double_t *x, Double_t *y) const
{
//
// Creates the partial sequence of X and Y coordinates to determine
//______________________________________________________________________
void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
Double_t x2, Double_t y2, Double_t d,
- Double_t &x, Double_t &y)
+ Double_t &x, Double_t &y) const
{
//
// Determines the X and Y of the first internal point of the Omega shape
Double_t b = (x1 - x2)*(y1 - y2);
Double_t c = (y1 - y2)*(y1 - y2) - d*d;
- // (Delta4 is Delta/4 because we use the reduced formula)
- Double_t Delta4 = b*b - a*c;
+ // (delta4 is Delta/4 because we use the reduced formula)
+ Double_t delta4 = b*b - a*c;
// Compute the slope of the two parallel lines
// (one of the two possible slopes, the one with the smaller
// absolute value is needed)
- if (Delta4 < 0) { // Should never happen with our data, but just to be sure
+ if (delta4 < 0) { // Should never happen with our data, but just to be sure
x = -1; // x is expected positive, so this flags an error
return;
} else
- m = (b + TMath::Sqrt(Delta4))/a; // b is negative with our data
+ m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data
// Finally compute the coordinates of the point
x = x2 + (y1 - y2 - d)/m;
void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
Double_t x2, Double_t y2,
Double_t x3, Double_t y3,
- Double_t &x, Double_t &y)
+ Double_t &x, Double_t &y) const
{
//
// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
}
//______________________________________________________________________
-void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
+void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SDD support cone and cylinder geometry as a
}
//______________________________________________________________________
-void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
+void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SSD support cone and cylinder geometry. as a
// of the carbon fiber cylinder was increased from 0.6 to 0.625mm
// Dimensions of the Central cylinder and flanges
- const Double_t kCylinderHalfLength = (1144.0/2) *fgkmm;
+ const Double_t kCylinderHalfLength = (1143.6/2) *fgkmm;
const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm;
const Double_t kCylinderThickness = 0.625*fgkmm;
const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
//______________________________________________________________________
void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the structure supporting the ITS cable trays on Side A
//
//______________________________________________________________________
void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SPD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
//
// Created: 15 Feb 2010 Mario Sitta
// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello and D.Elia
// (small differences with blueprints - e.g. -0.07mm in R1Trans and
// R2Trans - fix small overlaps; they are then compensated in positioning
// the Rear Tray to avoid its own overlaps with the rear supporting ring)
-// Optical cables and low voltage cables are approximated with mean
-// materials and square cross sections, but preserving the total material
-// budget.
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
//
// Overall position and rotation of the A-Side Cable Trays
const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
const Double_t kForwardTrayThick = 2.00 *fgkmm;
- const Int_t kForwardSideNpoints = 6;
+ const Int_t kForwardSideNpoints = 6;
const Double_t kExternalTrayLen = 1200.00 *fgkmm;
const Double_t kExternalTrayWide = kForwardTrayWide;
const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
const Double_t kExternalTrayThick = kForwardTrayThick;
- const Double_t kCoolingTubeRmin = 5.00 *fgkmm;
- const Double_t kCoolingTubeRmax = 6.00 *fgkmm;
+ const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
- const Double_t kLowVoltageCableSect = 3.412*fgkmm;//!!!ESTIMATED!!!
- const Double_t kHiVoltageCableSect = 1.873*fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
+ const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
+ const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
+ const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024*fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695*fgkmm;// Computed
+
+ const Double_t kTrayCCablesRot = 75.000*fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 227.000*fgkmm;// Computed
// Local variables
0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
0, 0, 1);
- // The optical fibers inside the forward tray: a BBox
- TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2,
- kOpticalFibersSect/2,
- kForwardTrayTotalLen/2);
+ // The optical fibers inside the forward tray: a Xtru
+ TGeoXtru *optFibsForw = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kOpticalFibersSect;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kOpticalFibersSect;
+
+ optFibsForw->DefinePolygon(6, xprof, yprof);
+ optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
+ optFibsForw->DefineSection(1, kOpticalFibersSect/2);
// The optical fibers inside the external tray: a Xtru
TGeoXtru *optFibsExt = new TGeoXtru(2);
optFibsExt->DefineSection(0, 0);
optFibsExt->DefineSection(1, kOpticalFibersSect);
- // The Low Voltage cables inside the forward tray: a BBox
- TGeoBBox *lowCablesForw = new TGeoBBox(kLowVoltageCableSect/2,
- kLowVoltageCableSect/2,
- kForwardTrayTotalLen/2);
+ // The Low Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *lowCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;
+
+ lowCablesForwCu->DefinePolygon(6, xprof, yprof);
+ lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);
+
+ TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);
- // The Low Voltage inside the external tray: a Xtru
- TGeoXtru *lowCablesExt = new TGeoXtru(2);
- lowCablesExt->SetName("ITSsuppSPDExtTrayLowVoltage");
+ xprof[0] = lowCablesForwCu->GetX(5);
+ yprof[0] = lowCablesForwCu->GetY(5);
+ xprof[1] = lowCablesForwCu->GetX(4);
+ yprof[1] = lowCablesForwCu->GetY(4);
+ xprof[2] = lowCablesForwCu->GetX(3);
+ yprof[2] = lowCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;
+
+ lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);
+
+ // The Low Voltage inside the external tray: two Xtru
+ TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
+ lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ 2*forwTrayWall->GetDY();
xprof[1] = kExternalTrayLen;
yprof[1] = yprof[0];
xprof[2] = xprof[1];
- yprof[2] = yprof[1] + kLowVoltageCableSect;
+ yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
yprof[3] = yprof[2];
xprof[3] = yprof[2]*TanD(kTrayAZRot);
- lowCablesExt->DefinePolygon(4, xprof, yprof);
- lowCablesExt->DefineSection(0, 0);
- lowCablesExt->DefineSection(1, kLowVoltageCableSect);
+ lowCablesExtCu->DefinePolygon(4, xprof, yprof);
+ lowCablesExtCu->DefineSection(0, 0);
+ lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
- // The High Voltage cables inside the forward tray: a BBox
- TGeoBBox *hiCablesForw = new TGeoBBox(kHiVoltageCableSect/2,
- kHiVoltageCableSect/2,
- kForwardTrayTotalLen/2);
+ TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
+ lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
+
+ xprof[0] = lowCablesExtCu->GetX(3);
+ yprof[0] = lowCablesExtCu->GetY(3);
+ xprof[1] = lowCablesExtCu->GetX(2);
+ yprof[1] = lowCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ lowCablesExtPUR->DefineSection(0, 0);
+ lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
+
+ // The High Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *hiCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;
+
+ hiCablesForwCu->DefinePolygon(6, xprof, yprof);
+ hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);
+
+ TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesForwCu->GetX(5);
+ yprof[0] = hiCablesForwCu->GetY(5);
+ xprof[1] = hiCablesForwCu->GetX(4);
+ yprof[1] = hiCablesForwCu->GetY(4);
+ xprof[2] = hiCablesForwCu->GetX(3);
+ yprof[2] = hiCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;
+
+ hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);
+
+ // The High Voltage inside the external tray: two Xtru
+ TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
+ hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
- // The High Voltage inside the external tray: a Xtru
- TGeoXtru *hiCablesExt = new TGeoXtru(2);
- hiCablesExt->SetName("ITSsuppSPDExtTrayHiVoltage");
+ hiCablesExtCu->DefinePolygon(4, xprof, yprof);
+ hiCablesExtCu->DefineSection(0, 0);
+ hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
+ hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
+
+ xprof[0] = hiCablesExtCu->GetX(3);
+ yprof[0] = hiCablesExtCu->GetY(3);
+ xprof[1] = hiCablesExtCu->GetX(2);
+ yprof[1] = hiCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ hiCablesExtPUR->DefineSection(0, 0);
+ hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ // The Coaxial cables inside the forward tray: two Xtru
+ TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
+ coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableSectCu/2;
+
+ coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
+ coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");
+
+ xprof[0] = coaxCablesForwCu->GetX(5);
+ yprof[0] = coaxCablesForwCu->GetY(5);
+ xprof[1] = coaxCablesForwCu->GetX(4);
+ yprof[1] = coaxCablesForwCu->GetY(4);
+ xprof[2] = coaxCablesForwCu->GetX(3);
+ yprof[2] = coaxCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableHighMeg/2;
+
+ coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);
+
+ // The Coaxial inside the external tray: two Xtru
+ TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
+ coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ 2*forwTrayWall->GetDY();
xprof[1] = kExternalTrayLen;
yprof[1] = yprof[0];
xprof[2] = xprof[1];
- yprof[2] = yprof[1] + kHiVoltageCableSect;
+ yprof[2] = yprof[1] + kCoaxCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtCu->DefineSection(0, 0);
+ coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
+
+ TGeoXtru *coaxCablesExtMeg = new TGeoXtru(2);
+ coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");
+
+ xprof[0] = coaxCablesExtCu->GetX(3);
+ yprof[0] = coaxCablesExtCu->GetY(3);
+ xprof[1] = coaxCablesExtCu->GetX(2);
+ yprof[1] = coaxCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoaxCableHighMeg/2;
yprof[3] = yprof[2];
xprof[3] = yprof[2]*TanD(kTrayAZRot);
- hiCablesExt->DefinePolygon(4, xprof, yprof);
- hiCablesExt->DefineSection(0, 0);
- hiCablesExt->DefineSection(1, kHiVoltageCableSect);
+ coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtMeg->DefineSection(0, 0);
+ coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);
// We have all shapes: now create the real volumes
TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
- TGeoMedium *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$");
- TGeoMedium *medHVC = mgr->GetMedium("ITS_SPD_HICABLES$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
forwTrayLowerFace, medAl);
extOptFibs->SetFillColor(extOptFibs->GetLineColor());
extOptFibs->SetFillStyle(4000); // 0% transparent
- TGeoVolume *forwLowCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayLowCabs",
- lowCablesForw, medLVC);
-
- forwLowCabs->SetVisibility(kTRUE);
- forwLowCabs->SetLineColor(kRed); // Red
- forwLowCabs->SetLineWidth(1);
- forwLowCabs->SetFillColor(forwLowCabs->GetLineColor());
- forwLowCabs->SetFillStyle(4000); // 0% transparent
-
- TGeoVolume *extLowCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayLowCabs",
- lowCablesExt, medLVC);
-
- extLowCabs->SetVisibility(kTRUE);
- extLowCabs->SetLineColor(kRed); // Red
- extLowCabs->SetLineWidth(1);
- extLowCabs->SetFillColor(extLowCabs->GetLineColor());
- extLowCabs->SetFillStyle(4000); // 0% transparent
-
- TGeoVolume *forwHiCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabs",
- hiCablesForw, medHVC);
-
- forwHiCabs->SetVisibility(kTRUE);
- forwHiCabs->SetLineColor(kRed); // Red
- forwHiCabs->SetLineWidth(1);
- forwHiCabs->SetFillColor(forwHiCabs->GetLineColor());
- forwHiCabs->SetFillStyle(4000); // 0% transparent
-
- TGeoVolume *extHiCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabs",
- hiCablesExt, medHVC);
-
- extHiCabs->SetVisibility(kTRUE);
- extHiCabs->SetLineColor(kRed); // Red
- extHiCabs->SetLineWidth(1);
- extHiCabs->SetFillColor(extHiCabs->GetLineColor());
- extHiCabs->SetFillStyle(4000); // 0% transparent
+ TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
+ lowCablesForwCu, medCu);
+
+ forwLowCabsCu->SetVisibility(kTRUE);
+ forwLowCabsCu->SetLineColor(kRed); // Red
+ forwLowCabsCu->SetLineWidth(1);
+ forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
+ forwLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
+ lowCablesForwPUR, medPUR);
+
+ forwLowCabsPUR->SetVisibility(kTRUE);
+ forwLowCabsPUR->SetLineColor(kBlack); // Black
+ forwLowCabsPUR->SetLineWidth(1);
+ forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
+ forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
+ lowCablesExtCu, medCu);
+
+ extLowCabsCu->SetVisibility(kTRUE);
+ extLowCabsCu->SetLineColor(kRed); // Red
+ extLowCabsCu->SetLineWidth(1);
+ extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
+ extLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
+ lowCablesExtPUR, medPUR);
+
+ extLowCabsPUR->SetVisibility(kTRUE);
+ extLowCabsPUR->SetLineColor(kBlack); // Black
+ extLowCabsPUR->SetLineWidth(1);
+ extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
+ extLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
+ hiCablesForwCu, medCu);
+
+ forwHiCabsCu->SetVisibility(kTRUE);
+ forwHiCabsCu->SetLineColor(kRed); // Red
+ forwHiCabsCu->SetLineWidth(1);
+ forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
+ forwHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
+ hiCablesForwPUR, medPUR);
+
+ forwHiCabsPUR->SetVisibility(kTRUE);
+ forwHiCabsPUR->SetLineColor(kBlack); // Black
+ forwHiCabsPUR->SetLineWidth(1);
+ forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
+ forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
+ hiCablesExtCu, medCu);
+
+ extHiCabsCu->SetVisibility(kTRUE);
+ extHiCabsCu->SetLineColor(kRed); // Red
+ extHiCabsCu->SetLineWidth(1);
+ extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
+ extHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
+ hiCablesExtPUR, medPUR);
+
+ extHiCabsPUR->SetVisibility(kTRUE);
+ extHiCabsPUR->SetLineColor(kBlack); // Black
+ extHiCabsPUR->SetLineWidth(1);
+ extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
+ extHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
+ coaxCablesForwCu, medCu);
+
+ forwCoaxCu->SetVisibility(kTRUE);
+ forwCoaxCu->SetLineColor(kRed); // Red
+ forwCoaxCu->SetLineWidth(1);
+ forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
+ forwCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
+ coaxCablesForwMeg, medMeg);
+
+ forwCoaxMeg->SetVisibility(kTRUE);
+ forwCoaxMeg->SetLineColor(kBlack); // Black
+ forwCoaxMeg->SetLineWidth(1);
+ forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
+ forwCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
+ coaxCablesExtCu, medCu);
+
+ extCoaxCu->SetVisibility(kTRUE);
+ extCoaxCu->SetLineColor(kRed); // Red
+ extCoaxCu->SetLineWidth(1);
+ extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
+ extCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
+ coaxCablesExtMeg, medMeg);
+
+ extCoaxMeg->SetVisibility(kTRUE);
+ extCoaxMeg->SetLineColor(kBlack); // Black
+ extCoaxMeg->SetLineWidth(1);
+ extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
+ extCoaxMeg->SetFillStyle(4000); // 0% transparent
// Now build up the trays
cableTrayAForw->AddNode(forwCoolTube, 1,
new TGeoTranslation(0, yloc, zloc));
- xloc = optFibsForw->GetDX() + coolTubeForw->GetRmax();
- yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + optFibsForw->GetDY();
- zloc = optFibsForw->GetDZ();
+ xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
cableTrayAForw->AddNode(forwOptFibs, 1,
- new TGeoTranslation(xloc, yloc, zloc));
-
- xloc = lowCablesForw->GetDX() + coolTubeForw->GetRmax();
- yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +lowCablesForw->GetDY();
- zloc = lowCablesForw->GetDZ();
- cableTrayAForw->AddNode(forwLowCabs, 1,
- new TGeoTranslation(-xloc, yloc, zloc));
-
- xloc = hiCablesForw->GetDX() + 2*lowCablesForw->GetDX()
- + coolTubeForw->GetRmax();
- yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + hiCablesForw->GetDY();
- zloc = hiCablesForw->GetDZ();
- cableTrayAForw->AddNode(forwHiCabs, 1,
- new TGeoTranslation(-xloc, yloc, zloc));
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwLowCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*lowCablesForwCu->GetZ(1) +
+ hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwHiCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
+ coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwCoaxCu, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
// To simplify following placement in MARS, origin is on top
yloc = -kExternalTrayHigh + kExternalTrayThick/2;
cableTrayAExt->AddNode(extCoolTube, 1,
new TGeoTranslation(0, yloc, zloc));
- xloc = kOpticalFibersSect + coolTubeExt->GetRmax();
+ xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
cableTrayAExt->AddNode(extOptFibs, 1,
new TGeoCombiTrans( xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
- xloc = kLowVoltageCableSect + coolTubeExt->GetRmax();
- cableTrayAExt->AddNode(extLowCabs, 1,
+ xloc = coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extLowCabsPUR, 1,
new TGeoCombiTrans(-xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
- xloc = 2*kHiVoltageCableSect + kLowVoltageCableSect + coolTubeExt->GetRmax();
- cableTrayAExt->AddNode(extHiCabs, 1,
+ xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extHiCabsCu, 1,
new TGeoCombiTrans(-xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
+ coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extCoaxCu, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
// Finally put everything in the mother volume
//______________________________________________________________________
void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SPD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
// Created: ??? Bjorn S. Nilsen
// Updated: 22 Apr 2010 Mario Sitta
// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
+// Updated: 20 Dec 2011 Mario Sitta Composite vol to avoid new overlap
//
// Technical data are taken from AutoCAD drawings and other (oral)
// information given by D.Elia
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
//
// Dimensions and positions of the C-Side Cable Tray elements
const Int_t kNumTraysSideC = 10;
+ const Double_t kTrayCCablesOutRot = 75.000 *fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 245.000 *fgkmm;// Computed
+
const Double_t kTrayCHalfWide = 6.350 *fgkcm;
const Double_t kTrayCLength1 = 172.800 *fgkcm;
const Double_t kTrayCLength2 = 189.300 *fgkcm;
const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
- const Double_t kCoolingTubeRmin = 5.000 *fgkmm;
- const Double_t kCoolingTubeRmax = 6.000 *fgkmm;
+ const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
- const Double_t kLowVoltageCableSect = 3.412 *fgkmm;//!!!ESTIMATED!!!
- const Double_t kHiVoltageCableSect = 1.873 *fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
+ const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
+ const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
+ const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024 *fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695 *fgkmm;// Computed
+
+ const Double_t kCablesYtrans = 2.500 *fgkmm;// Avoid ovlps
// Overall position and rotation of the C-Side Cable Trays
const Double_t kTraySideCRPos = 45.300 *fgkcm;
// The Cable Tray lower face: a Xtru
TGeoXtru *sideCHorFace = new TGeoXtru(2);
+ sideCHorFace->SetName("ITSsuppSPDTraySideCHor");
xprof[0] = 0.;
yprof[0] = 0.;
// The internal wall: a Xtru
TGeoXtru *intWall = new TGeoXtru(2);
+ intWall->SetName("ITSsuppSPDTraySideCWall");
xprof[0] = sideCHorFace->GetX(5);
yprof[0] = sideCHorFace->GetY(5);
0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
0, 0, 1);
+ // The part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
+ 0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
+ // The freon inside the part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
+ outTube->GetDz(),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
// The optical fibers inside the tray: a Xtru
TGeoXtru *optFibs = new TGeoXtru(2);
- xprof[0] = sideCMidFace->GetX(5);
- yprof[0] = sideCMidFace->GetY(5);
- xprof[1] = sideCMidFace->GetX(4);
- yprof[1] = sideCMidFace->GetY(4);
- xprof[2] = sideCMidFace->GetX(3);
- yprof[2] = sideCMidFace->GetY(3);
- xprof[3] = xprof[2] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
- yprof[3] = yprof[2] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
- InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
- kOpticalFibersSect , xprof[4], yprof[4]);
- xprof[5] = 0.;
- yprof[5] = yprof[0] + kOpticalFibersSect;
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kOpticalFibersSect , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kOpticalFibersSect;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kOpticalFibersSect;
- optFibs->DefinePolygon(6, xprof, yprof);
+ optFibs->DefinePolygon(8, xprof, yprof);
optFibs->DefineSection(0, 0);
optFibs->DefineSection(1, kOpticalFibersSect);
- // The low voltage cables inside the tray: a Xtru
- TGeoXtru *lowCables = new TGeoXtru(2);
-
- xprof[0] = sideCMidFace->GetX(5);
- yprof[0] = sideCMidFace->GetY(5);
- xprof[1] = sideCMidFace->GetX(4);
- yprof[1] = sideCMidFace->GetY(4);
- xprof[2] = sideCMidFace->GetX(3);
- yprof[2] = sideCMidFace->GetY(3);
- xprof[3] = xprof[2] - kLowVoltageCableSect*SinD(kTrayCFoldAngle);
- yprof[3] = yprof[2] + kLowVoltageCableSect*CosD(kTrayCFoldAngle);
- InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
- kLowVoltageCableSect , xprof[4], yprof[4]);
- xprof[5] = 0.;
- yprof[5] = yprof[0] + kLowVoltageCableSect;
-
- lowCables->DefinePolygon(6, xprof, yprof);
- lowCables->DefineSection(0, 0);
- lowCables->DefineSection(1, kLowVoltageCableSect);
-
- // The high voltage cables inside the tray: a Xtru
- TGeoXtru *hiCables = new TGeoXtru(2);
-
- xprof[0] = sideCMidFace->GetX(5);
- yprof[0] = sideCMidFace->GetY(5);
- xprof[1] = sideCMidFace->GetX(4);
- yprof[1] = sideCMidFace->GetY(4);
- xprof[2] = sideCMidFace->GetX(3);
- yprof[2] = sideCMidFace->GetY(3);
- xprof[3] = xprof[2] - kHiVoltageCableSect*SinD(kTrayCFoldAngle);
- yprof[3] = yprof[2] + kHiVoltageCableSect*CosD(kTrayCFoldAngle);
- InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
- kHiVoltageCableSect , xprof[4], yprof[4]);
- xprof[5] = 0.;
- yprof[5] = yprof[0] + kHiVoltageCableSect;
+ // The low voltage cables inside the tray: two Xtru
+ TGeoXtru *lowCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableSectCu;
+
+ lowCablesCu->DefinePolygon(8, xprof, yprof);
+ lowCablesCu->DefineSection(0, 0);
+ lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
+
+ TGeoXtru *lowCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = lowCablesCu->GetX(7);
+ yprof[0] = lowCablesCu->GetY(7);
+ xprof[1] = lowCablesCu->GetX(6);
+ yprof[1] = lowCablesCu->GetY(6);
+ xprof[2] = lowCablesCu->GetX(5);
+ yprof[2] = lowCablesCu->GetY(5);
+ xprof[3] = lowCablesCu->GetX(4);
+ yprof[3] = lowCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableHighPUR;
+
+ lowCablesPUR->DefinePolygon(8, xprof, yprof);
+ lowCablesPUR->DefineSection(0, 0);
+ lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
+
+ // The high voltage cables inside the tray: two Xtru
+ TGeoXtru *hiCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableSectCu;
+
+ hiCablesCu->DefinePolygon(8, xprof, yprof);
+ hiCablesCu->DefineSection(0, 0);
+ hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
+
+ TGeoXtru *hiCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesCu->GetX(7);
+ yprof[0] = hiCablesCu->GetY(7);
+ xprof[1] = hiCablesCu->GetX(6);
+ yprof[1] = hiCablesCu->GetY(6);
+ xprof[2] = hiCablesCu->GetX(5);
+ yprof[2] = hiCablesCu->GetY(5);
+ xprof[3] = hiCablesCu->GetX(4);
+ yprof[3] = hiCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableHighPUR;
+
+ hiCablesPUR->DefinePolygon(8, xprof, yprof);
+ hiCablesPUR->DefineSection(0, 0);
+ hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
+
+ // The coaxial cables inside the tray: two Xtru
+ TGeoXtru *coaxCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableSectCu;
+
+ coaxCablesCu->DefinePolygon(8, xprof, yprof);
+ coaxCablesCu->DefineSection(0, 0);
+ coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesMeg = new TGeoXtru(2);
+
+ xprof[0] = coaxCablesCu->GetX(7);
+ yprof[0] = coaxCablesCu->GetY(7);
+ xprof[1] = coaxCablesCu->GetX(6);
+ yprof[1] = coaxCablesCu->GetY(6);
+ xprof[2] = coaxCablesCu->GetX(5);
+ yprof[2] = coaxCablesCu->GetY(5);
+ xprof[3] = coaxCablesCu->GetX(4);
+ yprof[3] = coaxCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableHighMeg , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableHighMeg;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableHighMeg;
- hiCables->DefinePolygon(6, xprof, yprof);
- hiCables->DefineSection(0, 0);
- hiCables->DefineSection(1, kHiVoltageCableSect);
+ coaxCablesMeg->DefinePolygon(8, xprof, yprof);
+ coaxCablesMeg->DefineSection(0, 0);
+ coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);
+ // To avoid a newly discovered overlap,
+ // transform the two overlapping volumes into a Composite Shape
+ TGeoCompositeShape *trayIntern =
+ new TGeoCompositeShape("ITSSPDInternalTrayC",
+ "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");
// We have all shapes: now create the real volumes
TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
- TGeoMedium *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$");
- TGeoMedium *medHVC = mgr->GetMedium("ITS_SPD_HICABLES$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
- TGeoVolume *traySideCHorFace = new TGeoVolume("ITSsuppSPDTraySideCHor",
- sideCHorFace, medAl);
+ TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal",
+ trayIntern, medAl);
- traySideCHorFace->SetVisibility(kTRUE);
- traySideCHorFace->SetLineColor(6); // Purple
- traySideCHorFace->SetLineWidth(1);
- traySideCHorFace->SetFillColor(traySideCHorFace->GetLineColor());
- traySideCHorFace->SetFillStyle(4000); // 0% transparent
+ traySideCIntern->SetVisibility(kTRUE);
+ traySideCIntern->SetLineColor(6); // Purple
+ traySideCIntern->SetLineWidth(1);
+ traySideCIntern->SetFillColor(traySideCIntern->GetLineColor());
+ traySideCIntern->SetFillStyle(4000); // 0% transparent
TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid",
sideCMidFace, medAl);
traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
traySideCLongCover->SetFillStyle(4000); // 0% transparent
- TGeoVolume *traySideCIntWall = new TGeoVolume("ITSsuppSPDTraySideCWall",
- intWall, medAl);
-
- traySideCIntWall->SetVisibility(kTRUE);
- traySideCIntWall->SetLineColor(6); // Purple
- traySideCIntWall->SetLineWidth(1);
- traySideCIntWall->SetFillColor(traySideCIntWall->GetLineColor());
- traySideCIntWall->SetFillStyle(4000); // 0% transparent
-
TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
horTube, medIn);
traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
traySideCIncFreon->SetFillStyle(4000); // 0% transparent
+ TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
+ outTube, medIn);
+
+ traySideCOutTube->SetVisibility(kTRUE);
+ traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCOutTube->SetLineWidth(1);
+ traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
+ traySideCOutTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
+ outFreon, medFr);
+
+ traySideCOutFreon->SetVisibility(kTRUE);
+ traySideCOutFreon->SetLineColor(kBlue); // Blue
+ traySideCOutFreon->SetLineWidth(1);
+ traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
+ traySideCOutFreon->SetFillStyle(4000); // 0% transparent
+
TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
optFibs, medFibs);
traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
traySideCOptFibs->SetFillStyle(4000); // 0% transparent
- TGeoVolume *traySideCLowCabs = new TGeoVolume("ITSsuppSPDTraySideCLowCabs",
- lowCables, medLVC);
+ TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
+ lowCablesCu, medCu);
+
+ traySideCLowCabsCu->SetVisibility(kTRUE);
+ traySideCLowCabsCu->SetLineColor(kRed); // Red
+ traySideCLowCabsCu->SetLineWidth(1);
+ traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
+ traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
+ lowCablesPUR, medPUR);
+
+ traySideCLowCabsPUR->SetVisibility(kTRUE);
+ traySideCLowCabsPUR->SetLineColor(kBlack); // Black
+ traySideCLowCabsPUR->SetLineWidth(1);
+ traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
+ traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
+ hiCablesCu, medCu);
+
+ traySideCHiCabsCu->SetVisibility(kTRUE);
+ traySideCHiCabsCu->SetLineColor(kRed); // Red
+ traySideCHiCabsCu->SetLineWidth(1);
+ traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
+ traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
- traySideCLowCabs->SetVisibility(kTRUE);
- traySideCLowCabs->SetLineColor(kRed); // Red
- traySideCLowCabs->SetLineWidth(1);
- traySideCLowCabs->SetFillColor(traySideCLowCabs->GetLineColor());
- traySideCLowCabs->SetFillStyle(4000); // 0% transparent
+ TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
+ hiCablesPUR, medPUR);
- TGeoVolume *traySideCHiCabs = new TGeoVolume("ITSsuppSPDTraySideCHiCabs",
- hiCables, medHVC);
+ traySideCHiCabsPUR->SetVisibility(kTRUE);
+ traySideCHiCabsPUR->SetLineColor(kBlack); // Black
+ traySideCHiCabsPUR->SetLineWidth(1);
+ traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
+ traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
- traySideCHiCabs->SetVisibility(kTRUE);
- traySideCHiCabs->SetLineColor(kRed); // Red
- traySideCHiCabs->SetLineWidth(1);
- traySideCHiCabs->SetFillColor(traySideCHiCabs->GetLineColor());
- traySideCHiCabs->SetFillStyle(4000); // 0% transparent
+ TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
+ coaxCablesCu, medCu);
+
+ traySideCCoaxCu->SetVisibility(kTRUE);
+ traySideCCoaxCu->SetLineColor(kRed); // Red
+ traySideCCoaxCu->SetLineWidth(1);
+ traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
+ traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
+ coaxCablesMeg, medMeg);
+
+ traySideCCoaxMeg->SetVisibility(kTRUE);
+ traySideCCoaxMeg->SetLineColor(kBlack); // Black
+ traySideCCoaxMeg->SetLineWidth(1);
+ traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
+ traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent
// Now build up the trays
- cableTrayC->AddNode(traySideCHorFace,1,0);
+ cableTrayC->AddNode(traySideCIntern,1,0);
cableTrayC->AddNode(traySideCMidFace,1,0);
cableTrayC->AddNode(traySideCLongCover,1,0);
- cableTrayC->AddNode(traySideCIntWall,1,0);
-
traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
+ traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);
xloc = horTube->GetDz();
yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
new TGeoCombiTrans( xloc, yloc, 0,
new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
+ xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
+ yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
+ 2*outTube->GetRmax();
+ cableTrayC->AddNode(traySideCOutTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-70.,-90.,90.)));
+
zloc = horTube->GetRmax();
cableTrayC->AddNode(traySideCOptFibs, 1,
new TGeoTranslation( 0, 0, zloc));
- zloc = kLowVoltageCableSect + horTube->GetRmax();
- cableTrayC->AddNode(traySideCLowCabs, 1,
+ zloc = kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCLowCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCLowCabsPUR, 1,
new TGeoTranslation( 0, 0,-zloc));
- zloc = kHiVoltageCableSect + kLowVoltageCableSect + horTube->GetRmax();
- cableTrayC->AddNode(traySideCHiCabs, 1,
+ zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCHiCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCHiCabsPUR, 1,
new TGeoTranslation( 0, 0,-zloc));
+ zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCCoaxCu, 1,
+ new TGeoTranslation( 0, 0, zloc));
+ cableTrayC->AddNode(traySideCCoaxMeg, 1,
+ new TGeoTranslation( 0, 0, zloc));
+
// Finally put everything in the mother volume
for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SDD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
// Created: ??? Bjorn S. Nilsen
// Updated: 5 Jan 2010 Mario Sitta
// Updated: 26 Feb 2010 Mario Sitta
+// Updated: 06 Sep 2010 Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
const Double_t kTrayARTrans = 408.35 *fgkmm;
const Double_t kTrayAZTrans = 1011.00 *fgkmm;
const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
- const Double_t kExternTrayZTrans = 853.00 *fgkmm;
+ const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
+ const Double_t kExternTrayZTrans = 823.00 *fgkmm;
const Double_t kExternCoverYTrans = 2.00 *fgkmm;
const Double_t kTrayAZRot = (180-169.5);// Degrees
const Double_t kTrayAFirstRotAng = 22.00; // Degrees
const Double_t kTrayASecondRotAng = 15.00; // Degrees
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
const Int_t kForwardTrayNpoints = 8;
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideACoolManifWide = 8.23 *fgkcm;
+ const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
+ const Double_t kSideACoolManifLen = 3.90 *fgkcm;
+ const Double_t kSideACoolManifPOMFrac = 0.0054;
+ const Double_t kSideACoolManifSteelFrac= 0.8850;
+ const Double_t kSideACoolManifWaterFrac= 0.0913;
+ const Double_t kSideACoolManifAlFrac = 0.0183;
+
+ const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
+ const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
+ const Double_t kSideACoolTubesPURFrac = 0.5897;
+ const Double_t kSideACoolTubesWaterFrac= 0.4101;
+ const Double_t kSideACoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideAOptConnWide = 0.90 *fgkcm;
+ const Double_t kSideAOptConnLen = 1.37 *fgkcm;
+ const Double_t kSideAOptConnPBTFrac = 0.5010;
+ const Double_t kSideAOptConnSteelFrac = 0.1784;
+ const Double_t kSideAOptConnAlFrac = 0.3206;
+
+ const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
+
+ const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
+ const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
+ const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
+ const Double_t kSideAInputCablesCu = 0.7404;
+ const Double_t kSideAInputCablesPlast = 0.1269;
+ const Double_t kSideAInputCablesAl = 0.0057;
+ const Double_t kSideAInputCablesKapton = 0.0172;
+ const Double_t kSideAInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
+ const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
+ const Double_t kSideAOutputCablesCu = 0.6783;
+ const Double_t kSideAOutputCablesPlast = 0.1605;
+ const Double_t kSideAOutputCablesAl = 0.0078;
+ const Double_t kSideAOutputCablesKapton= 0.0232;
+ const Double_t kSideAOutputCablesPOLYAX= 0.1302;
+
+ const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
+ const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
+ const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
+ const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
+ const Double_t kSideAPCBBoardsCu = 0.3864;
+ const Double_t kSideAPCBBoardsEpoxy = 0.1486;
+ const Double_t kSideAPCBBoardsPlast = 0.0578;
+ const Double_t kSideAPCBBoardsSteel = 0.1521;
+ const Double_t kSideAPCBBoardsPPS = 0.2551;
+
// Local variables
Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
- Double_t xloc, yloc, zloc, alpharot;
+ Double_t xloc, yloc, zloc, alpharot, height;
// The whole tray as an assembly
// First create all needed shapes
// The forward tray is very complex and deserves a dedicated method
- TGeoVolumeAssembly *forwardTray = CreateSDDForwardTraySideA(mgr);
+ CreateSDDForwardTraySideA(cableTrayA,mgr);
// The forward cover: a Xtru
TGeoXtru *forwardCover = new TGeoXtru(2);
// The external covers: a Composite Shape
TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifAlFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ // The cooling tubes: three Xtru's
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
+
+ xprof[0] = kSideACoolManifLen;
+ yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
+ xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
+ kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
+ yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
+ kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
+ kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
+ IntersectLines( 0 , xprof[0], yprof[0],
+ TanD(kTrayAZRot), xprof[2], yprof[2],
+ xprof[1], yprof[1]);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
- // We have all shapes: now create the real volumes
- TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
- TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
- TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
- forwardCover, medAl);
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
- forwardTrayCover->SetVisibility(kTRUE);
- forwardTrayCover->SetLineColor(kMagenta+1); // Purple
- forwardTrayCover->SetLineWidth(1);
- forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
- forwardTrayCover->SetFillStyle(4000); // 0% transparent
+ height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
- TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
- externalTray, medAl);
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
- externalTraySDD->SetVisibility(kTRUE);
- externalTraySDD->SetLineColor(6); // Purple
- externalTraySDD->SetLineWidth(1);
- externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
- externalTraySDD->SetFillStyle(4000); // 0% transparent
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
- TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
- externCover, medAntic);
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
- externTrayCover->SetVisibility(kTRUE);
- externTrayCover->SetLineColor(kMagenta+1); // Purple
- externTrayCover->SetLineWidth(1);
- externTrayCover->SetFillColor(externTrayCover->GetLineColor());
- externTrayCover->SetFillStyle(4000); // 0% transparent
+ height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
+
+ // The optical fiber connectors: three boxes
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnAlFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = kSideAOptConnLen;
+ yprof[0] = coolTubesPUR->GetY(0);
+ xprof[1] = coolTubesPUR->GetX(1);
+ yprof[1] = coolTubesPUR->GetY(1);
+ xprof[2] = coolTubesPUR->GetX(2);
+ yprof[2] = coolTubesPUR->GetY(2);
+ xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideAOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideAOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
+
+ // The input cables: five boxes
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesCu*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPlast*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesAl*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesKapton*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
+
+ xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
+ forwardCover, medAl);
+
+ forwardTrayCover->SetVisibility(kTRUE);
+ forwardTrayCover->SetLineColor(kMagenta+1); // Purple
+ forwardTrayCover->SetLineWidth(1);
+ forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
+ forwardTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
+ externalTray, medAl);
+
+ externalTraySDD->SetVisibility(kTRUE);
+ externalTraySDD->SetLineColor(6); // Purple
+ externalTraySDD->SetLineWidth(1);
+ externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
+ externalTraySDD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
+ externCover, medAntic);
+
+ externTrayCover->SetVisibility(kTRUE);
+ externTrayCover->SetLineColor(kMagenta+1); // Purple
+ externTrayCover->SetLineWidth(1);
+ externTrayCover->SetFillColor(externTrayCover->GetLineColor());
+ externTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
// Now build up the tray
- yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) +
- kExternTrayTotalHeight +
- kExternCoverSideThick - kForwardTrayTailHeight;
- zloc = kTrayAZToSupportRing - kForwardCoverLength;
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
+ zloc = kForwardTrayUpperLength - kForwardCoverLength;
cableTrayA->AddNode(forwardTrayCover, 1,
new TGeoTranslation( 0, yloc, zloc) );
Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
- kExternCoverYTrans;
- yloc = totalhi*(1 - CosD(kTrayAZRot));
+ yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternTrayTotalHeight*CosD(kTrayAZRot);
zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
cableTrayA->AddNode(externalTraySDD, 1,
new TGeoCombiTrans( 0, yloc, zloc,
new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
- yloc = kExternTrayTotalHeight - kExternCoverYTrans;
- zloc = kExternTrayZTrans - yloc*SinD(kTrayAZRot);
- yloc *= CosD(kTrayAZRot);
- zloc += totalhi*SinD(kTrayAZRot);
- yloc += totalhi*(1 - CosD(kTrayAZRot));
+ yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
+ zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
cableTrayA->AddNode(externTrayCover,1,
new TGeoCombiTrans( 0, yloc, zloc,
new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
+ yloc = kForwardTrayThick + coolManifPOM->GetDY();
+ zloc = coolManifPOM->GetDZ();
+ cableTrayA->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
- // Finally put everything in the mother volume
- alpharot = -kTrayAFirstRotAng;
- xloc = kTrayARTrans*SinD(alpharot);
- yloc = kTrayARTrans*CosD(alpharot);
- zloc = kTrayAZTrans;
- moth->AddNode(cableTrayA,1,
- new TGeoCombiTrans( xloc, yloc, zloc,
- new TGeoRotation("",-alpharot,0,0) ) );
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ cableTrayA->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
- alpharot += 180;
- xloc = kTrayARTrans*SinD(alpharot);
- yloc = kTrayARTrans*CosD(alpharot);
- moth->AddNode(cableTrayA,2,
- new TGeoCombiTrans( xloc, yloc, zloc,
- new TGeoRotation("",-alpharot,0,0) ) );
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ cableTrayA->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
- alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
- xloc = kTrayARTrans*SinD(alpharot);
- yloc = kTrayARTrans*CosD(alpharot);
- moth->AddNode(cableTrayA,3,
- new TGeoCombiTrans( xloc, yloc, zloc,
- new TGeoRotation("",-alpharot,0,0) ) );
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ cableTrayA->AddNode(alCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(purCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(waterCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(airCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
+ yloc = kForwardTrayThick + optConnPBT->GetDY();
+ zloc = optConnPBT->GetDZ();
+ cableTrayA->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(pbtOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ cableTrayA->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(steelOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ cableTrayA->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(alOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+ xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
+ cableTrayA->AddNode(optFibs,1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(optFibs,2,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
+ kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
+ zloc = inputCabsPOLYAX->GetDZ();
+ cableTrayA->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
+ cableTrayA->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
+ cableTrayA->AddNode(alInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
+ cableTrayA->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
+ cableTrayA->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
+ zloc += pcbBoardsPPS->GetDZ();
+ cableTrayA->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
+ cableTrayA->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
+ cableTrayA->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
+ cableTrayA->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
+ cableTrayA->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(cuOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(plastOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(alOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(kaptonOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(polyaxOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
- alpharot += 180;
- xloc = kTrayARTrans*SinD(alpharot);
- yloc = kTrayARTrans*CosD(alpharot);
- moth->AddNode(cableTrayA,4,
- new TGeoCombiTrans( xloc, yloc, zloc,
- new TGeoRotation("",-alpharot,0,0) ) );
- // To avoid putting an assembly inside another assembly,
- // the forwardTray is put directly in the mother volume
+ // Finally put everything in the mother volume
Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
kExternCoverSideThick -
kForwardTrayTailHeight;
yloc = rforw*CosD(alpharot);
zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
- moth->AddNode(forwardTray,1,
+ moth->AddNode(cableTrayA,1,
new TGeoCombiTrans( xloc, yloc, zloc,
new TGeoRotation("",-alpharot,0,0) ) );
alpharot += 180;
xloc = rforw*SinD(alpharot);
yloc = rforw*CosD(alpharot);
- moth->AddNode(forwardTray,2,
+ moth->AddNode(cableTrayA,2,
new TGeoCombiTrans( xloc, yloc, zloc,
new TGeoRotation("",-alpharot,0,0) ) );
alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
xloc = rforw*SinD(alpharot);
yloc = rforw*CosD(alpharot);
- moth->AddNode(forwardTray,3,
+ moth->AddNode(cableTrayA,3,
new TGeoCombiTrans( xloc, yloc, zloc,
new TGeoRotation("",-alpharot,0,0) ) );
alpharot += 180;
xloc = rforw*SinD(alpharot);
yloc = rforw*CosD(alpharot);
- moth->AddNode(forwardTray,4,
+ moth->AddNode(cableTrayA,4,
new TGeoCombiTrans( xloc, yloc, zloc,
new TGeoRotation("",-alpharot,0,0) ) );
//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SDD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
// information given by F.Tosello
//
- // Dimensions and positions of the C-Side Cable Tray elements
+ // Dimensions and positions of the C-Side Cable Tray
+ // (Change accordingly to CreateSDDSSDTraysSideC !)
const Int_t kNumTraySideC = 4;
+ const Double_t kSideCHalfThick = 0.100 *fgkcm;
+ const Double_t kSideCLength1 = 172.800 *fgkcm;
+ const Double_t kSideCLength2 = 189.300 *fgkcm;
+ const Double_t kBarCoolRmax = 0.4 *fgkcm;
+ const Double_t kXShiftBarCool = 13.00 *fgkcm;
+
const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
+ const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
+ const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
+ const Double_t kSideCCoolManifPOMFrac = 0.0051;
+ const Double_t kSideCCoolManifSteelFrac= 0.8502;
+ const Double_t kSideCCoolManifWaterFrac= 0.0868;
+ const Double_t kSideCCoolManifAlFrac = 0.0579;
+
+ const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
+ const Double_t kSideCCoolTubesPURFrac = 0.5884;
+ const Double_t kSideCCoolTubesWaterFrac= 0.4114;
+ const Double_t kSideCCoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
+ const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
+ const Double_t kSideCOptConnPBTFrac = 0.6798;
+ const Double_t kSideCOptConnSteelFrac = 0.2421;
+ const Double_t kSideCOptConnAlFrac = 0.0781;
+
+ const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
+ const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
+
+ const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
+ const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
+ const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
+ const Double_t kSideCInputCablesCu = 0.7405;
+ const Double_t kSideCInputCablesPlast = 0.1268;
+ const Double_t kSideCInputCablesAl = 0.0057;
+ const Double_t kSideCInputCablesKapton = 0.0172;
+ const Double_t kSideCInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
+ const Double_t kSideCOutputCablesWide = 8.50 *fgkcm;
+ const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
+ const Double_t kSideCOutputCablesCu = 0.6775;
+ const Double_t kSideCOutputCablesPlast = 0.1613;
+ const Double_t kSideCOutputCablesAl = 0.0078;
+ const Double_t kSideCOutputCablesKapton= 0.0234;
+ const Double_t kSideCOutputCablesPOLYAX= 0.1300;
+
+ const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
+ const Double_t kSideCPCBBoardsCu = 0.3864;
+ const Double_t kSideCPCBBoardsEpoxy = 0.1491;
+ const Double_t kSideCPCBBoardsPlast = 0.0579;
+ const Double_t kSideCPCBBoardsSteel = 0.1517;
+ const Double_t kSideCPCBBoardsPPS = 0.2549;
+
// Overall position and rotation of the C-Side Cable Trays
const Double_t kTraySideCRPos = 45.30 *fgkcm;
const Double_t kTraySideCZPos = -102.40 *fgkcm;
// Local variables
-// Double_t xprof[12], yprof[12];
- Double_t xloc, yloc, alpharot, alphafold;
+ Double_t xprof[6], yprof[6];
+ Double_t height, xloc, yloc, zloc, alpharot, alphafold;
// The assembly holding the metallic structure
- // We need four of them because the content is different
- TGeoVolumeAssembly *trayStructure[kNumTraySideC];
- for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
- char name[20];
- sprintf(name,"ITSsupportSDDTrayC%d",jt);
- trayStructure[jt] = CreateSDDSSDTraysSideC(name);
- }
+ TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
+
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ // The cooling tubes: three Xtru's
+ alpharot = kSideCFoldAngle*TMath::DegToRad();
+
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
+
+ xprof[0] = 2*kSideCCoolManifHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
+
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
+
+ // The optical fiber connectors: three boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnAlFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = 2*kSideCOptConnHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideCOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideCOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
+
+ // The input cables: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesCu*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPlast*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesAl*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesKapton*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
+
+ xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
// We have all shapes: now create the real volumes
- TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
- if (0==1) medAl->Print();
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+ // Now fill the tray
+ xloc = coolManifPOM->GetDX();
+ yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
+ trayStructure->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ trayStructure->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ trayStructure->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ trayStructure->AddNode(alCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ xloc = inputCabsCu->GetDX();
+ yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
+ + kSideCInputCablesTrans;
+ trayStructure->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
+ trayStructure->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
+ trayStructure->AddNode(alInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
+ trayStructure->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
+ trayStructure->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ trayStructure->AddNode(purCoolTubes , 1, 0);
+ trayStructure->AddNode(waterCoolTubes, 1, 0);
+ trayStructure->AddNode(airCoolTubes , 1, 0);
+
+ xloc = optConnPBT->GetDX();
+ yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
+ zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
+ trayStructure->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(pbtOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ trayStructure->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(steelOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ trayStructure->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(alOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ trayStructure->AddNode(optFibs, 1,
+ new TGeoTranslation( 0, 0, zloc) );
+ trayStructure->AddNode(optFibs, 2,
+ new TGeoTranslation( 0, 0,-zloc) );
+
+ trayStructure->AddNode(cuOutputCabs , 1, 0);
+ trayStructure->AddNode(plastOutputCabs , 1, 0);
+ trayStructure->AddNode(alOutputCabs , 1, 0);
+ trayStructure->AddNode(kaptonOutputCabs, 1, 0);
+ trayStructure->AddNode(polyaxOutputCabs, 1, 0);
+
+ xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
+ yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
+ trayStructure->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
+ trayStructure->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
+ trayStructure->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
+ trayStructure->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
+ trayStructure->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
// Finally put everything in the mother volume
alphafold = kSideCFoldAngle;
alpharot = kTraySideCAlphaRot[jt];
xloc = kTraySideCRPos*SinD(alpharot);
yloc = kTraySideCRPos*CosD(alpharot);
- moth->AddNode(trayStructure[jt],1,
+ moth->AddNode(trayStructure,jt+1,
new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
}
//______________________________________________________________________
void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SSD cable trays which are outside the ITS support cones
// but still inside the TPC on Side A
//______________________________________________________________________
void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the SSD cable trays which are outside the ITS support cones
// but still inside the TPC on Side C
const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
+ const Double_t kCablesYtrans = 2.50 *fgkmm;// Avoid ovlps
// Overall position and rotation of the C-Side Cable Trays
const Double_t kTraySideCRPos = 45.30 *fgkcm;
// Copper lies on the lower plate: get position of its points
TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
xprof[0] = lowerplate->GetX(5);
- yprof[0] = lowerplate->GetY(5);
+ yprof[0] = lowerplate->GetY(5) + kCablesYtrans;
xprof[1] = lowerplate->GetX(4);
- yprof[1] = lowerplate->GetY(4);
+ yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
xprof[2] = lowerplate->GetX(3);
- yprof[2] = lowerplate->GetY(3);
+ yprof[2] = lowerplate->GetY(3) + kCablesYtrans;
xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
water->DefineSection(1, kServicesWidth/2);
// The poliurethane inside the tray: a Xtru
- TGeoXtru *PUR = new TGeoXtru(2);
- PUR->SetName("ITSsuppSSDTrayCPUR");
-
+ TGeoXtru *pur = new TGeoXtru(2);
+ pur->SetName("ITSsuppSSDTrayCPUR");
xprof[0] = water->GetX(5);
yprof[0] = water->GetY(5);
xprof[1] = water->GetX(4);
xprof[5] = xprof[0];
yprof[5] = yprof[0] + kPoliUrethaneHeight;
- PUR->DefinePolygon(6, xprof, yprof);
- PUR->DefineSection(0, -kServicesWidth/2);
- PUR->DefineSection(1, kServicesWidth/2);
+ pur->DefinePolygon(6, xprof, yprof);
+ pur->DefineSection(0, -kServicesWidth/2);
+ pur->DefineSection(1, kServicesWidth/2);
// We have all shapes: now create the real volumes
trayWater->SetFillStyle(4000); // 0% transparent
TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
- PUR, medPUR);
+ pur, medPUR);
trayPolyUr->SetVisibility(kTRUE);
trayPolyUr->SetLineColor(kGray); // Gray
}
//______________________________________________________________________
-TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoManager *mgr){
+void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
+ const TGeoManager *mgr){
//
// Creates the forward SDD tray on Side A (0872/G/D/01)
//
// Input:
+// tray : the TGeoVolumeAssembly to put the elements in
// mgr : the GeoManager (used only to get the proper material)
//
// Output:
//
-// Return: a TGeoVolumeAssembly for the tray
+// Return:
//
// Created: 08 Jan 2010 Mario Sitta
+// Updated: 07 Sep 2010 Mario Sitta
//
// Technical data are taken from AutoCAD drawings, L.Simonetti technical
// drawings and other (oral) information given by F.Tosello
// The tray has a very complex shape, so it is made by assembling
- // different elements (with some small simplifications): the result
- // is a TGeoAssembly returned to the caller
- TGeoVolumeAssembly *forwardTray = new TGeoVolumeAssembly("ITSsuppSDDForwardTray");
+ // different elements (with some small simplifications)
// The tray base: a BBox
zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
// Now build up the tray
yloc = kForwardTrayThick/2;
zloc = zlen;
- forwardTray->AddNode(forwTrayBase, 1,
- new TGeoTranslation(0, yloc, zloc) );
+ tray->AddNode(forwTrayBase, 1,
+ new TGeoTranslation(0, yloc, zloc) );
xloc = kForwardTrayBaseHalfWide;
- forwardTray->AddNode(forwTraySide1, 1,
- new TGeoCombiTrans(xloc, 0, 0,
+ tray->AddNode(forwTraySide1, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
xloc = -xloc + kForwardTrayThick;
- forwardTray->AddNode(forwTraySide1, 2,
- new TGeoCombiTrans(xloc, 0, 0,
+ tray->AddNode(forwTraySide1, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
- forwardTray->AddNode(forwTraySide2, 1, 0);
+ tray->AddNode(forwTraySide2, 1, 0);
zloc = kForwardTraySideLength;
- forwardTray->AddNode(forwTraySide2, 2,
- new TGeoCombiTrans(0, 0, zloc,
+ tray->AddNode(forwTraySide2, 2,
+ new TGeoCombiTrans(0, 0, zloc,
new TGeoRotation("",90,-180,-90)));
xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
- forwardTray->AddNode(forwTraySide3, 1,
- new TGeoCombiTrans(xloc, 0, 0,
+ tray->AddNode(forwTraySide3, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
xloc = -xloc + kForwardTrayThick;
- forwardTray->AddNode(forwTraySide3, 2,
- new TGeoCombiTrans(xloc, 0, 0,
+ tray->AddNode(forwTraySide3, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
new TGeoRotation("",90,-90,-90)));
xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
- kForwardTrayHorWingWide/2;
yloc = traySide3->GetY(2) + kForwardTrayThick/2;
zloc = kForwardTraySideLength - trayHorWing->GetDZ();
- forwardTray->AddNode(forwTrayHWing, 1,
- new TGeoTranslation( xloc, yloc, zloc) );
- forwardTray->AddNode(forwTrayHWing, 2,
- new TGeoTranslation(-xloc, yloc, zloc) );
+ tray->AddNode(forwTrayHWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayHWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
- kForwardTrayVertWingWide/2;
yloc = traySide3->GetY(2) + trayVertWing->GetDY();
zloc = traySide3->GetX(3) + kForwardTrayThick/2;
- forwardTray->AddNode(forwTrayVWing, 1,
- new TGeoTranslation( xloc, yloc, zloc) );
- forwardTray->AddNode(forwTrayVWing, 2,
- new TGeoTranslation(-xloc, yloc, zloc) );
+ tray->AddNode(forwTrayVWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayVWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
- return forwardTray;
+ return;
}
//______________________________________________________________________
//______________________________________________________________________
TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
- const char *trayName,
- TGeoManager *mgr){
+ const char *trayName,
+ const TGeoManager *mgr){
//
// Creates the SDD and SSD Trays on Side C which are supposedly identical
return cableTrayC;
}
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the elements suspending the ITS to the TPC and other fixed
+// elements used to hook the rails (0872/C and its daughters)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Return:
+//
+// Created: 28 Oct 2010 Mario Sitta
+// Updated: 18 Feb 2011 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the half ring C2/C3 (0872/C/04)
+ const Double_t kRingCZPos = 733.000*fgkmm;
+ const Double_t kRingCZToTPC = 5.500*fgkmm;
+
+ const Double_t kRingCThick = 12.000*fgkmm;
+ const Double_t kRingCRmin = 565.000*fgkmm;
+ const Double_t kRingCRmax = 592.000*fgkmm;
+ const Double_t kRingCHeight = 560.000*fgkmm;
+ const Double_t kRingCXToInsert = 515.000*fgkmm;
+ const Double_t kRingCYToInsert = 113.000*fgkmm;
+
+ const Int_t kNumberOfRingPoints = 23; // N.points to approximate arc
+
+ // Dimensions of the forward upper hook (0872/C/09)
+ const Double_t kForwUpHookThick = 20.000*fgkmm;
+ const Double_t kForwUpHookRext = 590.000*fgkmm;
+ const Double_t kForwUpHookRint = 20.000*fgkmm;
+ const Double_t kForwUpHookHiTot = 89.000*fgkmm;
+ const Double_t kForwUpHookHiInt = 59.000*fgkmm;
+ const Double_t kForwUpHookWide = 96.000*fgkmm;
+ const Double_t kForwUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwUpHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kForwUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kForwUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleY = 8.000*fgkmm;
+ const Double_t kForwUpHookHollowHi = 35.000*fgkmm;
+ const Double_t kForwUpHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwUpHookPts = 11;
+ const Int_t kNumbOfForwUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/08)
+ const Double_t kForwLwHookThick = 20.000*fgkmm;
+ const Double_t kForwLwHookRext = 590.000*fgkmm;
+ const Double_t kForwLwHookRint = 20.000*fgkmm;
+ const Double_t kForwLwHookHiTot = 88.500*fgkmm;
+ const Double_t kForwLwHookWide = 96.000*fgkmm;
+ const Double_t kForwLwHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwLwHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwLwHookYToHollow = 3.500*fgkmm;
+ const Double_t kForwLwHookHoleR = 7.500*fgkmm;
+ const Double_t kForwLwHookHoleIntHi = 35.000*fgkmm;
+ const Double_t kForwLwHookHoleYPos = 13.500*fgkmm;
+ const Double_t kForwLwHookHollowHi = 62.000*fgkmm;
+ const Double_t kForwLwHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwLwHookPts = 11;
+ const Int_t kNumbOfForwLwHookHolePts= 7;
+
+ // Dimensions of the rear upper hook (0872/C/10)
+ const Double_t kRearUpHookThick = 15.000*fgkmm;
+ const Double_t kRearUpHookRext = 590.000*fgkmm;
+ const Double_t kRearUpHookRint = 20.000*fgkmm;
+ const Double_t kRearUpHookHiTot = 53.500*fgkmm;
+ const Double_t kRearUpHookHiInt = 23.500*fgkmm;
+ const Double_t kRearUpHookWide = 96.000*fgkmm;
+ const Double_t kRearUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kRearUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleY = 8.000*fgkmm;
+
+ const Int_t kNumberOfRearUpHookPts = 10;
+ const Int_t kNumbOfRearUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/11)
+ const Double_t kRearLwHookThick = 20.000*fgkmm;
+ const Double_t kRearLwHookRext = 590.000*fgkmm;
+ const Double_t kRearLwHookHiTot = 30.000*fgkmm;
+ const Double_t kRearLwHookWide = 96.000*fgkmm;
+
+ const Int_t kNumberOfRearLwHookPts = 3;
+
+ // Dimensions of the rear lower brackets (0872/C/16)
+ const Double_t kRearLwBracketThick = 15.000*fgkmm;
+ const Double_t kRearLwBracketHi1 = 42.000*fgkmm;
+ const Double_t kRearLwBracketHi2 = 12.000*fgkmm;
+ const Double_t kRearLwBracketWide1 = 34.000*fgkmm;
+ const Double_t kRearLwBracketWide2 = 10.000*fgkmm;
+// const Double_t kRearLwBracketR5 = 5.000*fgkmm
+
+ // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
+ const Double_t kForwWebSStirrDep = 20.000*fgkmm;
+ const Double_t kForwWebSStirrLen1 = 15.000*fgkmm;
+ const Double_t kForwWebSStirrLen2 = 55.000*fgkmm;
+ const Double_t kForwWebSStirrLen3 = 10.000*fgkmm;
+ const Double_t kForwWebSStirrWide1 = 45.000*fgkmm;
+ const Double_t kForwWebSStirrWide2 = 38.000*fgkmm;
+ const Double_t kForwWebSStirrWide3 = 23.000*fgkmm;
+ const Double_t kForwWebTStirrThick = 5.000*fgkmm;
+ const Double_t kForwWebTStirrWide1 = 30.000*fgkmm;
+ const Double_t kForwWebTStirrWide2 = 10.000*fgkmm;
+ const Double_t kForwWebTStirrTotLen3= 58.500*fgkmm;
+ const Double_t kForwWebTStirrTotLen4= 36.000*fgkmm;
+ const Double_t kForwWebTStirrLen1 = 10.000*fgkmm;
+
+ // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
+ const Double_t kFRWebClampThick = 10.000*fgkmm;
+ const Double_t kFRWebClampExtWide = 30.000*fgkmm;
+ const Double_t kFRWebClampIntWide = 18.000*fgkmm;
+ const Double_t kFRWebClampExtHi = 22.000*fgkmm;
+ const Double_t kFRWebClampIntHi = 17.000*fgkmm;
+
+ // Dimensions of the webcam itself
+ const Double_t kWebcamLength = 35.000*fgkmm;//ESTIMATED!!!
+
+ // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
+ const Double_t kRearUpWebStirrWide = 76.000*fgkmm;
+ const Double_t kRearUpWebStirrDep = 15.000*fgkmm;
+ const Double_t kRearUpWebStirrThick = 5.000*fgkmm;
+ const Double_t kRearUpWebStirrH1 = 27.000*fgkmm;
+ const Double_t kRearUpWebStirrH2 = 32.000*fgkmm;
+ const Double_t kRearUpWebBarLen = 130.000*fgkmm;
+ const Double_t kRearUpWebBarHi = 20.000*fgkmm;
+ const Double_t kRearUpWebBarThick = 5.000*fgkmm;
+
+ // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
+ const Double_t kUpperSlideTotHeight = 93.500*fgkmm;
+ const Double_t kUpperSlideBlockHi = 62.500*fgkmm;
+ const Double_t kUpperSlideWidth = 36.000*fgkmm;
+ const Double_t kUpperSlideTotDepth = 51.000*fgkmm;
+ const Double_t kUpperSlideIntDepth = 36.000*fgkmm;
+ const Double_t kUpperSlideStubHi = 15.000*fgkmm;
+ const Double_t kUpperSlideStubDep = 8.000*fgkmm;
+ const Double_t kUpperSlideWheelHi = 18.500*fgkmm;
+ const Double_t kUpperSlideHoleRout = 11.000*fgkmm;
+ const Double_t kUpperSlideHoleRint1 = 9.000*fgkmm;
+ const Double_t kUpperSlideHoleRint2 = 11.500*fgkmm;
+ const Double_t kUpperSlideHoleH1 = 7.000*fgkmm;
+ const Double_t kUpperSlideHoleH2 = 46.000*fgkmm;
+ const Double_t kUpperSlideHoleH3 = 1.100*fgkmm;
+ const Double_t kUpperSlideHoleXPos = 20.000*fgkmm;
+ const Double_t kUpperSlidePinRmin = 4.000*fgkmm;
+ const Double_t kUpperSlidePinRmax = 6.000*fgkmm;
+ const Double_t kUpperSlidePinH1 = 7.000*fgkmm;
+ const Double_t kUpperSlidePinH2 = 46.000*fgkmm;
+ const Double_t kUpperSlidePinH3 = 25.500*fgkmm;
+
+ // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
+ const Double_t kLowerSlideTotHeight = 80.000*fgkmm;
+ const Double_t kLowerSlideBlockHi = 28.000*fgkmm;
+ const Double_t kLowerSlideWidth = 36.000*fgkmm;
+ const Double_t kLowerSlideTotDepth = 60.000*fgkmm;
+ const Double_t kLowerSlideHoleRout = 9.500*fgkmm;
+ const Double_t kLowerSlideHoleRint = 4.700*fgkmm;
+ const Double_t kLowerSlideHoleH1 = 12.000*fgkmm;
+ const Double_t kLowerSlideNoseBase = 40.000*fgkmm;
+ const Double_t kLowerSlideNoseBasHi = 6.000*fgkmm;//Computed
+ const Double_t kLowerSlideNoseUpWid = 25.000*fgkmm;
+ const Double_t kLowerSlideNoseDepth = 10.000*fgkmm;
+ const Double_t kLowerSlidePinRmin = 3.000*fgkmm;
+ const Double_t kLowerSlidePinRmax = 4.000*fgkmm;
+ const Double_t kLowerSlidePinH1 = 12.000*fgkmm;
+ const Double_t kLowerSlidePinH2 = 10.000*fgkmm;
+
+ // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
+ const Double_t kStirrCXPos = 759.000*fgkmm;
+ const Double_t kStirrCZPos = 1867.000*fgkmm;
+
+ const Double_t kStirrC12Thick = 15.000*fgkmm;
+ const Double_t kStirrC12TotLen = 314.000*fgkmm;
+ const Double_t kStirrC12BodyHalfHi = 95.000*fgkmm;
+ const Double_t kStirrC12BodyLen = 153.000*fgkmm;
+ const Double_t kStirrC12HeadLen = 50.000*fgkmm;
+ const Double_t kStirrC12HeadHalfHi = 165.000*fgkmm;
+ const Double_t kStirrC12HeadIntHi = 114.000*fgkmm;
+ const Double_t kStirrC12HeadIntLen = 45.000*fgkmm;
+ const Double_t kStirrC12TailLen = 14.000*fgkmm;
+ const Double_t kStirrC12R100 = 100.000*fgkmm;
+ const Double_t kStirrC12R50 = 50.000*fgkmm;
+ const Double_t kStirrC12R10 = 10.000*fgkmm;
+ const Double_t kStirrC12HeadAng = 40.000; // Degree
+
+ const Int_t kNumberOfStirrCPoints = 23;
+
+ // Dimensions and positions of the C5 rail stirrups (0872/C/05)
+ const Double_t kStirrC5BodyLen = 155.000*fgkmm;
+
+
+ // Local variables
+ Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
+ Double_t xpos, ypos, zpos, alpha;
+ Double_t xdummy, ydummy;
+
+
+ // First create all needed shapes
+
+ // The Supporting Ring (0872/C/04): a really complex Xtru
+ // to approximate the arc with a polyline
+ TGeoXtru *ringC2C3 = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The external arc
+ xprof[j] = kRingCRmax*SinD(90*j/10);
+ yprof[j] = kRingCRmax*CosD(90*j/10);
+ }
+
+ xprof[11] = kRingCRmin;
+ yprof[11] = yprof[10];
+
+ alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
+ xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
+ yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
+ xprof[13] = kRingCRmin*TMath::Cos(alpha);
+ yprof[13] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[14] = kRingCXToInsert;
+ yprof[14] = yprof[13];
+
+ alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
+ xprof[15] = kRingCRmin*TMath::Cos(alpha);
+ yprof[15] = kRingCRmin*TMath::Sin(alpha);
+
+ for (Int_t j=7; j>1; j--) { // The internal arc
+ xprof[23-j] = kRingCRmin*SinD(90*j/10);
+ yprof[23-j] = kRingCRmin*CosD(90*j/10);
+ }
+
+ alpha = TMath::ASin(kRingCHeight/kRingCRmin); // The angle till the notch
+ xprof[22] = kRingCRmin*TMath::Cos(alpha);
+ yprof[22] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[23] = xprof[0];
+ yprof[23] = yprof[22];
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 22; jp++) {
+ xprof[24+jp] = -xprof[23-1-jp];
+ yprof[24+jp] = yprof[23-1-jp];
+ }
+
+ // wow! now the actual Xtru
+ ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
+ ringC2C3->DefineSection(0, 0);
+ ringC2C3->DefineSection(1, kRingCThick);
+
+ // The Forward Upper Hook (0872/C/09): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
+ forwUpHookMainBody->SetName("ITSforwUpHookMainBody");
+
+ xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
+ yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
+ xprof[ 1] = kForwUpHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwUpHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
+ yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
+ forwUpHookMainBody->DefineSection(0, 0);
+ forwUpHookMainBody->DefineSection(1, kForwUpHookThick);
+
+ // The hole
+ TGeoXtru *forwUpHookHole = new TGeoXtru(2);
+ forwUpHookHole->SetName("ITSforwUpHookHole");
+
+ xprof[0] = kForwUpHookHoleBase/2;
+ yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
+ xprof[1] = kForwUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
+ xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kForwUpHookHoleR5;
+ yprof[4] = yprof[0] + kForwUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
+ forwUpHookHole->DefineSection(0, -0.1);
+ forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
+ 0.55*kForwUpHookHollowHi,
+ 0.55*kForwUpHookHollowWide);
+ forwUpHookHollow->SetName("ITSforwUpHookHollow");
+
+ TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
+ forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
+ forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
+ forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
+ forwUpHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");
+
+ // The Forward Lower Hook (0872/C/08): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
+ forwLwHookMainBody->SetName("ITSforwLwHookMainBody");
+
+ xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
+ yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
+ xprof[ 1] = kForwLwHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
+ - kForwLwHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwLwHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
+ yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
+ forwLwHookMainBody->DefineSection(0, 0);
+ forwLwHookMainBody->DefineSection(1, kForwLwHookThick);
+
+ // The hole
+ TGeoXtru *forwLwHookHole = new TGeoXtru(2);
+ forwLwHookHole->SetName("ITSforwLwHookHole");
+
+ xprof[0] = 0;
+ yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
+ - kForwLwHookHoleR;
+ for (Int_t j=1; j<3; j++) {
+ xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
+ yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
+ }
+ xprof[3] = xprof[0] + kForwLwHookHoleR;
+ yprof[3] = yprof[0] + kForwLwHookHoleR;
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
+ for (Int_t j=1; j<3; j++) {
+ xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
+ yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
+ }
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[4] + kForwLwHookHoleR;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
+ xprof[8+jp] = -xprof[6-jp];
+ yprof[8+jp] = yprof[6-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
+ forwLwHookHole->DefineSection(0, -0.1);
+ forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
+ 0.55*kForwLwHookHollowHi,
+ 0.55*kForwLwHookHollowWide);
+ forwLwHookHollow->SetName("ITSforwLwHookHollow");
+
+ TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
+ forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
+ forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
+ forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
+ forwLwHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");
+
+ // The Rear Upper Hook (0872/C/10): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // and another Xtru for the hole
+ // The main body
+ TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
+ rearUpHookMainBody->SetName("ITSrearUpHookMainBody");
+
+ xprof[0] = kRearUpHookHalfBase;
+ yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
+ yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 7] = kRearUpHookWide/2;
+ yprof[ 7] = yprof[5];
+ xprof[ 8] = xprof[7];
+ alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
+ yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
+ xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
+ yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
+ xprof[10] = 0;
+ yprof[10] = kRearUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
+ xprof[11+jp] = -xprof[9-jp];
+ yprof[11+jp] = yprof[9-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
+ rearUpHookMainBody->DefineSection(0, 0);
+ rearUpHookMainBody->DefineSection(1, kRearUpHookThick);
+
+ // The hole
+ TGeoXtru *rearUpHookHole = new TGeoXtru(2);
+ rearUpHookHole->SetName("ITSrearUpHookHole");
+
+ xprof[0] = kRearUpHookHoleBase/2;
+ yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
+ xprof[1] = kRearUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
+ xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kRearUpHookHoleR5;
+ yprof[4] = yprof[0] + kRearUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
+ rearUpHookHole->DefineSection(0, -0.1);
+ rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");
+
+ // The Rear Lower Hook (0872/C/11): a Xtru
+ TGeoXtru *rearLwHookShape = new TGeoXtru(2);
+ rearLwHookShape->SetName("ITSrearLwHookShape");
+
+ xprof[0] = kRearLwHookWide/2;
+ yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
+ xprof[1] = xprof[0];
+ alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
+ yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
+ xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
+ yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
+ xprof[3] = 0;
+ yprof[3] = kRearLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
+ xprof[4+jp] = -xprof[2-jp];
+ yprof[4+jp] = yprof[2-jp];
+ }
+
+ // Now the actual Xtru
+ rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
+ rearLwHookShape->DefineSection(0, 0);
+ rearLwHookShape->DefineSection(1, kRearLwHookThick);
+
+ // The Rear Lower Bracket (0872/C/16): a Xtru
+ TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
+ rearLwBrackShape->SetName("ITSrearLwBrackShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearLwBracketHi2;
+ xprof[3] = xprof[2] - kRearLwBracketWide1;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearLwBracketHi1;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ rearLwBrackShape->DefinePolygon(6, xprof, yprof);
+ rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
+ rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);
+
+ // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
+ TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kForwWebSStirrLen1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kForwWebSStirrWide1;
+ xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwWebSStirrWide3;
+ xprof[5] = xprof[4] - kForwWebSStirrLen3;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[0] + kForwWebSStirrWide2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
+ forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
+ forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);
+
+ // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
+ TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);
+
+ xprof[0] = -kForwWebTStirrWide2/2;
+ yprof[0] = 0;
+ xprof[1] = -kForwWebTStirrWide1/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kForwWebTStirrLen1;
+ xprof[3] =-xprof[2];
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[1];
+ xprof[5] =-xprof[0];
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr3Sh->DefineSection(0, 0);
+ forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);
+
+ TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);
+
+ yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
+ yprof[7] = yprof[6];
+
+ forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr4Sh->DefineSection(0, 0);
+ forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);
+
+ // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
+ TGeoXtru *frWebClampSh = new TGeoXtru(2);
+
+ xprof[0] = kFRWebClampIntWide/2;
+ yprof[0] = kFRWebClampIntHi;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = kFRWebClampExtWide/2;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = kFRWebClampExtHi;
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ frWebClampSh->DefinePolygon(8, xprof, yprof);
+ frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
+ frWebClampSh->DefineSection(1, kFRWebClampThick/2);
+
+ // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
+ TGeoXtru *upWebStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
+ xprof[3] = xprof[2] - kRearUpWebStirrThick;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearUpWebStirrH1;
+ xprof[5] = xprof[4] + kRearUpWebStirrWide;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[5] + kRearUpWebStirrH2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ upWebStirrSh->DefinePolygon(8, xprof, yprof);
+ upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
+ upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);
+
+ // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
+ TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
+ kRearUpWebBarHi/2,
+ kRearUpWebBarThick/2);
+
+ // The Webcam: a BBox
+ TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
+ kWebcamLength/2,
+ kFRWebClampIntHi/2);
+
+ // The Upper Wheel Slide (0872/C/Z/00-01-02)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
+ // (a Pcon) (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *upSlideAirSh = new TGeoXtru(2);
+ upSlideAirSh->SetName("ITSupperSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0];
+ yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
+ xprof[2] = xprof[1] - kUpperSlideIntDepth;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideTotHeight;
+ xprof[4] = xprof[3] + kUpperSlideTotDepth;
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[0];
+
+ upSlideAirSh->DefinePolygon(6, xprof, yprof);
+ upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
+ upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *upSlideAluSh = new TGeoXtru(2);
+ upSlideAluSh->SetName("ITSupperSlideAluShape");
+
+ xprof[0] = upSlideAirSh->GetX(0);
+ yprof[0] = upSlideAirSh->GetY(0);
+ xprof[1] = upSlideAirSh->GetX(1);
+ yprof[1] = upSlideAirSh->GetY(1);
+ xprof[2] = xprof[1] - kUpperSlideStubDep;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideStubHi;
+ xprof[4] = upSlideAirSh->GetX(2);
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[4] - kUpperSlideBlockHi;
+ xprof[6] = upSlideAirSh->GetX(5);
+ yprof[6] = yprof[5];
+ xprof[7] = xprof[6];
+ yprof[7] = yprof[0];
+
+ upSlideAluSh->DefinePolygon(8, xprof, yprof);
+ upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
+ upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
+ upSlideHoleSh->SetName("ITSupperSlideHoleShape");
+
+ zpos = upSlideAluSh->GetY(5);
+ upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
+ zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
+ - 2*kUpperSlideHoleH1);
+ upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
+ zpos += kUpperSlideHoleH3;
+ upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
+ upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
+ zpos += kUpperSlideHoleH2;
+ upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
+ upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);
+
+ TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
+ new TGeoRotation("",0,-90,0) );
+ upSlideHolePos->SetName("ITSupperSlideHolePos");
+ upSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
+ upSlidePinSh->SetName("ITSupperSlidePinShape");
+
+ zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
+ + kUpperSlidePinH3 - kUpperSlideBlockHi);
+ upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH3;
+ upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
+ upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
+ zpos += kUpperSlidePinH2;
+ upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
+ upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH1;
+ upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);
+
+ // The Lower Wheel Slide (0872/C/W/00-01-02-03)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
+ // (a Xtru) and the Steel pin (a Pcon)
+ // (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
+ lwSlideAirSh->SetName("ITSlowerSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
+ xprof[3] = xprof[2] - kLowerSlideTotDepth;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ lwSlideAirSh->DefinePolygon(6, xprof, yprof);
+ lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
+ lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
+ lwSlideAluSh->SetName("ITSlowerSlideAluShape");
+
+ xprof[0] = lwSlideAirSh->GetX(0);
+ yprof[0] = lwSlideAirSh->GetY(0);
+ xprof[1] = lwSlideAirSh->GetX(1);
+ yprof[1] = lwSlideAirSh->GetY(1);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kLowerSlideBlockHi;
+ xprof[3] = lwSlideAirSh->GetX(3);
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlideBlockHi;
+ xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = lwSlideAirSh->GetY(4);
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ lwSlideAluSh->DefinePolygon(8, xprof, yprof);
+ lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
+ lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
+ lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");
+
+ zpos = lwSlideAluSh->GetY(2);
+ lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
+ zpos += kLowerSlideHoleH1;
+ lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
+ lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
+ zpos = lwSlideAluSh->GetY(4);
+ lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);
+
+ TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
+ 0, 0,
+ new TGeoRotation("",0,-90,0) );
+ lwSlideHolePos->SetName("ITSlowerSlideHolePos");
+ lwSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");
+
+ // The Aluminum nose: a Xtru
+ TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
+ lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");
+
+ xprof[0] = lwSlideAluSh->GetX(5);
+ yprof[0] = lwSlideAluSh->GetY(5);
+ xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
+ xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
+ yprof[3] = lwSlideAluSh->GetY(6);
+ xprof[4] = xprof[0];
+ yprof[4] = yprof[3];
+
+ lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
+ lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
+ lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
+ lwSlidePinSh->SetName("ITSlowerSlidePinShape");
+
+ zpos = lwSlideAirSh->GetY(2);
+ lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
+ zpos += kLowerSlidePinH2;
+ lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
+ lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
+ zpos += kLowerSlidePinH1;
+ lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);
+
+ // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
+ // to approximate arcs with polylines
+ TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The internal arc
+ xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
+ yprof[j] = kStirrC12R50*SinD(90*j/10);
+ }
+
+ xprof[11] = xprof[10] + kStirrC12TailLen;
+ yprof[11] = yprof[10];
+ xprof[12] = xprof[11];
+ yprof[12] = kStirrC12BodyHalfHi;
+ xprof[13] = xprof[12] - kStirrC12BodyLen;
+ yprof[13] = yprof[12];
+
+ xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
+ yprof[17] = kStirrC12HeadHalfHi;
+ IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
+ kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
+ xprof[16], yprof[16], xdummy, ydummy);
+ alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
+ xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
+ yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
+ xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
+ yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));
+
+ xprof[18] = xprof[17] - kStirrC12HeadLen;
+ yprof[18] = yprof[17];
+ xprof[19] = xprof[18];
+ yprof[19] = kStirrC12HeadIntHi;
+ xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
+ yprof[20] = yprof[19];
+ for (Int_t j=1; j<4; j++) {
+ xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
+ yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
+ }
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
+ xprof[24+jp] = xprof[23-jp];
+ yprof[24+jp] = -yprof[23-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
+ stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);
+
+ // The first element of the Stirrup on the Forward side (0872/C/05):
+ // a really complex Xtru (equal to part of the Muon Stirrup)
+ // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
+ TGeoXtru *stirrupC5Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<13; j++) { // The internal arc and the tail
+ xprof[j] = stirrupC1C2Sh->GetX(j);
+ yprof[j] = stirrupC1C2Sh->GetY(j);
+ }
+
+ xprof[13] = xprof[12] - kStirrC5BodyLen;
+ yprof[13] = yprof[12];
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < 13; jp++) {
+ xprof[14+jp] = xprof[13-jp];
+ yprof[14+jp] = -yprof[13-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC5Sh->DefinePolygon(27, xprof, yprof);
+ stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAlcoa = mgr->GetMedium("ITS_ALCOAAL$");
+ TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
+ TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medErgal = mgr->GetMedium("ITS_ERGAL$");
+ TGeoMedium *medAisi = mgr->GetMedium("ITS_AISI304L$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPlexy = mgr->GetMedium("ITS_PLEXYGLAS$");
+ TGeoMedium *medPVC = mgr->GetMedium("ITS_PVC$");
+
+
+ TGeoVolume *suppRingC2C3 = new TGeoVolume("ITSTPCsupportRingC2C3",
+ ringC2C3, medAlcoa);
+
+ suppRingC2C3->SetVisibility(kTRUE);
+ suppRingC2C3->SetLineColor(6); // Purple
+ suppRingC2C3->SetLineWidth(1);
+ suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
+ suppRingC2C3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwUpHook = new TGeoVolume("ITSTPCsupportForwUpHook",
+ forwUpHookShape, medHokotol);
+
+ forwUpHook->SetVisibility(kTRUE);
+ forwUpHook->SetLineColor(6); // Purple
+ forwUpHook->SetLineWidth(1);
+ forwUpHook->SetFillColor(forwUpHook->GetLineColor());
+ forwUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLwHook = new TGeoVolume("ITSTPCsupportForwLwHook",
+ forwLwHookShape, medHokotol);
+
+ forwLwHook->SetVisibility(kTRUE);
+ forwLwHook->SetLineColor(6); // Purple
+ forwLwHook->SetLineWidth(1);
+ forwLwHook->SetFillColor(forwLwHook->GetLineColor());
+ forwLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearUpHook = new TGeoVolume("ITSTPCsupportRearUpHook",
+ rearUpHookShape, medHokotol);
+
+ rearUpHook->SetVisibility(kTRUE);
+ rearUpHook->SetLineColor(6); // Purple
+ rearUpHook->SetLineWidth(1);
+ rearUpHook->SetFillColor(rearUpHook->GetLineColor());
+ rearUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwHook = new TGeoVolume("ITSTPCsupportRearLwHook",
+ rearLwHookShape, medAnticor);
+
+ rearLwHook->SetVisibility(kTRUE);
+ rearLwHook->SetLineColor(6); // Purple
+ rearLwHook->SetLineWidth(1);
+ rearLwHook->SetFillColor(rearLwHook->GetLineColor());
+ rearLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwBrack = new TGeoVolume("ITSTPCsupportRearLwBracket",
+ rearLwBrackShape, medAnticor);
+
+ rearLwBrack->SetVisibility(kTRUE);
+ rearLwBrack->SetLineColor(6); // Purple
+ rearLwBrack->SetLineWidth(1);
+ rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
+ rearLwBrack->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebSStirrup = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
+ forwWebSStirrSh, medAnticor);
+
+ forwWebSStirrup->SetVisibility(kTRUE);
+ forwWebSStirrup->SetLineColor(6); // Purple
+ forwWebSStirrup->SetLineWidth(1);
+ forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
+ forwWebSStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr3 = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
+ forwWebTStirr3Sh, medAnticor);
+
+ forwWebTStirr3->SetVisibility(kTRUE);
+ forwWebTStirr3->SetLineColor(6); // Purple
+ forwWebTStirr3->SetLineWidth(1);
+ forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
+ forwWebTStirr3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr4 = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
+ forwWebTStirr4Sh, medAnticor);
+
+ forwWebTStirr4->SetVisibility(kTRUE);
+ forwWebTStirr4->SetLineColor(6); // Purple
+ forwWebTStirr4->SetLineWidth(1);
+ forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
+ forwWebTStirr4->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *frWebClamp = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
+ frWebClampSh, medPlexy);
+
+ frWebClamp->SetVisibility(kTRUE);
+ frWebClamp->SetLineColor(kAzure);
+ frWebClamp->SetLineWidth(1);
+ frWebClamp->SetFillColor(frWebClamp->GetLineColor());
+ frWebClamp->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upWebStirrup = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
+ upWebStirrSh, medAnticor);
+
+ upWebStirrup->SetVisibility(kTRUE);
+ upWebStirrup->SetLineColor(6); // Purple
+ upWebStirrup->SetLineWidth(1);
+ upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
+ upWebStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upRearWebBar = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
+ upRearWebBarSh, medPlexy);
+
+ upRearWebBar->SetVisibility(kTRUE);
+ upRearWebBar->SetLineColor(kAzure);
+ upRearWebBar->SetLineWidth(1);
+ upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
+ upRearWebBar->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *webCam = new TGeoVolume("ITSTPCsupportWebcam",
+ webcamShape, medPVC);
+
+ webCam->SetVisibility(kTRUE);
+ webCam->SetLineColor(kBlack);
+ webCam->SetLineWidth(1);
+ webCam->SetFillColor(webCam->GetLineColor());
+ webCam->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlideVol = new TGeoVolume("ITSTPCsupportUpperSlide",
+ upSlideAirSh, medAir);
+
+ upSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *upSlideBlock = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
+ upSlideBlockSh, medAnticor);
+
+ upSlideBlock->SetVisibility(kTRUE);
+ upSlideBlock->SetLineColor(6); // Purple
+ upSlideBlock->SetLineWidth(1);
+ upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
+ upSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlidePin = new TGeoVolume("ITSTPCsupportUpperSlidePin",
+ upSlidePinSh, medAisi);
+
+ upSlidePin->SetVisibility(kTRUE);
+ upSlidePin->SetLineColor(kGray);
+ upSlidePin->SetLineWidth(1);
+ upSlidePin->SetFillColor(upSlidePin->GetLineColor());
+ upSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideVol = new TGeoVolume("ITSTPCsupportLowerSlide",
+ lwSlideAirSh, medAir);
+
+ lwSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *lwSlideBlock = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
+ lwSlideBlockSh, medAnticor);
+
+ lwSlideBlock->SetVisibility(kTRUE);
+ lwSlideBlock->SetLineColor(6); // Purple
+ lwSlideBlock->SetLineWidth(1);
+ lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
+ lwSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideNose = new TGeoVolume("ITSTPCsupportLowerSlideNose",
+ lwSlideNoseSh, medAnticor);
+
+ lwSlideNose->SetVisibility(kTRUE);
+ lwSlideNose->SetLineColor(6); // Purple
+ lwSlideNose->SetLineWidth(1);
+ lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
+ lwSlideNose->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlidePin = new TGeoVolume("ITSTPCsupportLowerSlidePin",
+ lwSlidePinSh, medAisi);
+
+ lwSlidePin->SetVisibility(kTRUE);
+ lwSlidePin->SetLineColor(kGray);
+ lwSlidePin->SetLineWidth(1);
+ lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
+ lwSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC1C2 = new TGeoVolume("ITSTPCsupportStirrupC1C2",
+ stirrupC1C2Sh, medErgal);
+
+ stirrC1C2->SetVisibility(kTRUE);
+ stirrC1C2->SetLineColor(6); // Purple
+ stirrC1C2->SetLineWidth(1);
+ stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
+ stirrC1C2->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC5 = new TGeoVolume("ITSTPCsupportStirrupC5",
+ stirrupC5Sh, medErgal);
+
+ stirrC5->SetVisibility(kTRUE);
+ stirrC5->SetLineColor(6); // Purple
+ stirrC5->SetLineWidth(1);
+ stirrC5->SetFillColor(stirrC5->GetLineColor());
+ stirrC5->SetFillStyle(4000); // 0% transparent
+
+
+ // Build up the wheel slides
+ upSlideVol->AddNode(upSlideBlock,1,0);
+ upSlideVol->AddNode(upSlidePin, 1,
+ new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+ lwSlideVol->AddNode(lwSlideBlock,1,0);
+ lwSlideVol->AddNode(lwSlideNose ,1,0);
+ lwSlideVol->AddNode(lwSlidePin, 1,
+ new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+
+ // Finally put everything in the mother volume
+ moth->AddNode(suppRingC2C3,1,
+ new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
+ moth->AddNode(suppRingC2C3,2,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,0.) ) );
+ moth->AddNode(suppRingC2C3,3,
+ new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
+ new TGeoRotation("",0.,0.,180.) ) );
+ moth->AddNode(suppRingC2C3,4,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwUpHook,1,
+ new TGeoTranslation( 0, 0, zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwLwHook,1,
+ new TGeoCombiTrans( 0, 0, zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
+ moth->AddNode(rearUpHook,1,
+ new TGeoTranslation( 0, 0,-zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
+ moth->AddNode(rearLwHook,1,
+ new TGeoCombiTrans( 0, 0,-zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ xpos = kRearLwHookWide/2 + kRearLwBracketThick/2;
+ ypos = -kRingCHeight;
+ moth->AddNode(rearLwBrack,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(rearLwBrack,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ xpos = kForwUpHookWide/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwWebSStirrup,1,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+ xpos = kForwLwHookWide/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
+ moth->AddNode(forwWebSStirrup,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ xpos = kForwUpHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
+ zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
+ moth->AddNode(forwWebTStirr3,1,
+ new TGeoTranslation( xpos, ypos, zpos) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,1,
+ new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,1,
+ new TGeoTranslation( xpos, ypos,
+ zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kForwLwHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
+ moth->AddNode(forwWebTStirr4,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 180., 0., 0.) ) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,2,
+ new TGeoTranslation( xpos,-ypos,
+ zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
+ ypos = kRingCHeight;
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upWebStirrup,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upWebStirrup,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+
+ ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
+ zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
+ - upRearWebBarSh->GetDZ();
+ moth->AddNode(upRearWebBar,1,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ zpos -= upRearWebBarSh->GetDZ();
+ moth->AddNode(frWebClamp,3,
+ new TGeoCombiTrans( 0, ypos,-zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ zpos -= webcamShape->GetDZ();
+ moth->AddNode(webCam,3,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14);
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upSlideVol,1,
+ new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,2,
+ new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,3,
+ new TGeoCombiTrans( xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(upSlideVol,4,
+ new TGeoCombiTrans(-xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ moth->AddNode(lwSlideVol,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,2,
+ new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,3,
+ new TGeoCombiTrans( xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+ moth->AddNode(lwSlideVol,4,
+ new TGeoCombiTrans(-xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
+ moth->AddNode(stirrC1C2,1,
+ new TGeoTranslation( xpos, 0, zpos) );
+ moth->AddNode(stirrC1C2,2,
+ new TGeoCombiTrans(-xpos, 0, zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+ xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14); // Slides are all at the same height
+ zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
+ moth->AddNode(upSlideVol,5,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,6,
+ new TGeoCombiTrans(-xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,5,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,6,
+ new TGeoCombiTrans(-xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
+ moth->AddNode(stirrC5,1,
+ new TGeoTranslation( xpos, 0,-zpos) );
+ moth->AddNode(stirrC5,2,
+ new TGeoCombiTrans(-xpos, 0,-zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+
+ return;
+}
+