#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);
- endcapairshape->DefinePolygon(24,xair,yair);
- endcapairshape->DefineSection(0,-kHalfLengthEndCap);
- endcapairshape->DefineSection(1, kHalfLengthEndCap);
+ // Finally create the single Xtru volumes
+ TGeoXtru *upendcapshape = new TGeoXtru(2);
+ upendcapshape->SetName("upEC");
- // Create the Omega insert
- TGeoXtru *endcapomegashape = new TGeoXtru(2);
+ 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];
+ }
- CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+ upendcapshape->DefinePolygon(24,xXtru,yXtru);
+ upendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ upendcapshape->DefineSection(1, kHalfLengthEndCap);
- endcapomegashape->DefinePolygon(48,xomega,yomega);
- endcapomegashape->DefineSection(0,-kHalfLengthEndCap);
- endcapomegashape->DefineSection(1, kHalfLengthEndCap);
+ TGeoXtru *lowendcapshape = new TGeoXtru(2);
+ lowendcapshape->SetName("lwEC");
- // 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.
+ 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];
+ }
+
+ lowendcapshape->DefinePolygon(24,xXtru,yXtru);
+ lowendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ lowendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ 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);
- // Filled portions
- TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
- TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
+ // 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);
+
+ // 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(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) ));
- 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));
+ 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::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
new TGeoCombiTrans( xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
- xloc = 2*optFibsForw->GetZ(1) + lowCablesForwCu->GetZ(1) +
- coolTubeForw->GetRmax();
+ xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
cableTrayAForw->AddNode(forwLowCabsCu, 1,
- new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoCombiTrans(-xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
cableTrayAForw->AddNode(forwLowCabsPUR, 1,
- new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoCombiTrans(-xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
- xloc = 2*optFibsForw->GetZ(1) + 2*lowCablesForwCu->GetZ(1) +
+ 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 TGeoCombiTrans(-xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
cableTrayAForw->AddNode(forwHiCabsPUR, 1,
- new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoCombiTrans(-xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
- xloc = coaxCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ 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 TGeoCombiTrans( xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
cableTrayAForw->AddNode(forwCoaxMeg, 1,
- new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoCombiTrans( xloc, yloc, 0,
new TGeoRotation("",-90.,90.,90.)));
// To simplify following placement in MARS, origin is on top
//______________________________________________________________________
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
// 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
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;
const Double_t kTraySideCZPos = -102.400 *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);
xprof[0] = -kTrayCCablesZLenOut;
yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
xprof[1] = sideCMidFace->GetX(5);
- yprof[1] = sideCMidFace->GetY(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
xprof[2] = sideCMidFace->GetX(4);
- yprof[2] = sideCMidFace->GetY(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
xprof[3] = sideCMidFace->GetX(3);
- yprof[3] = sideCMidFace->GetY(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],
xprof[0] = -kTrayCCablesZLenOut;
yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
xprof[1] = sideCMidFace->GetX(5);
- yprof[1] = sideCMidFace->GetY(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
xprof[2] = sideCMidFace->GetX(4);
- yprof[2] = sideCMidFace->GetY(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
xprof[3] = sideCMidFace->GetX(3);
- yprof[3] = sideCMidFace->GetY(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],
xprof[0] = -kTrayCCablesZLenOut;
yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
xprof[1] = sideCMidFace->GetX(5);
- yprof[1] = sideCMidFace->GetY(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
xprof[2] = sideCMidFace->GetX(4);
- yprof[2] = sideCMidFace->GetY(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
xprof[3] = sideCMidFace->GetX(3);
- yprof[3] = sideCMidFace->GetY(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],
xprof[0] = -kTrayCCablesZLenOut;
yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
xprof[1] = sideCMidFace->GetX(5);
- yprof[1] = sideCMidFace->GetY(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
xprof[2] = sideCMidFace->GetX(4);
- yprof[2] = sideCMidFace->GetY(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
xprof[3] = sideCMidFace->GetX(3);
- yprof[3] = sideCMidFace->GetY(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],
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 *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);
// 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);
//______________________________________________________________________
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
//______________________________________________________________________
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
const Double_t kSideCInputCablesPOLYAX = 0.1098;
const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
- const Double_t kSideCOutputCablesWide = 8.30 *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;
//______________________________________________________________________
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],
//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
- TGeoManager *mgr){
+ const TGeoManager *mgr){
//
// Creates the forward SDD tray on Side A (0872/G/D/01)
//
//______________________________________________________________________
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_ALUMINUM$"); // To code!!!!!!
+ 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;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff