#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 = 405.*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,kTheta,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,kTheta,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];
- // Filled portions
- TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
- TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
+ TGeoXtru *omgendcapshape = new TGeoXtru(2);
+ omgendcapshape->SetName("omEC");
+ omgendcapshape->DefinePolygon(48,xomega,yomega);
+ omgendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ omgendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ // Finally the actual shape
+ TGeoCompositeShape *endcapshape = new TGeoCompositeShape("endcapTS",
+ "upEC+lwEC+omEC");
+
+ // The filler block: a Xtru
+ TGeoXtru *fillershape = new TGeoXtru(2);
+
+ xXtru[0] = omgendcapshape->GetX(1) + 0.0002; // Avoid thiny extrusion
+ yXtru[0] = omgendcapshape->GetY(1);
+ xXtru[1] = omgendcapshape->GetX(0) + 0.0002;
+ yXtru[1] = omgendcapshape->GetY(0);
+ xXtru[2] = omgendcapshape->GetX(47) - 0.0002;
+ yXtru[2] = omgendcapshape->GetY(47);
+ xXtru[3] = omgendcapshape->GetX(46);
+ yXtru[3] = omgendcapshape->GetY(46);
+
+ fillershape->DefinePolygon(4,xXtru,yXtru);
+ fillershape->DefineSection(0,-kFillerBlockLength/2);
+ fillershape->DefineSection(1, kFillerBlockLength/2);
+
+ // The hole in the filler: a Tube (made of air)
+ TGeoTube *fillerholeshape = new TGeoTube(0, kFillerBlockHoleR,
+ kFillerBlockLength/2);
+
+ // The filler bar: a BBox
+ Double_t fside = omgendcapshape->GetY(14) - omgendcapshape->GetY(13);
+ TGeoBBox *fillbarshape = new TGeoBBox(fside/2, fside/2, kFillerBarLength/2);
+
+ // 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]);
- 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]);
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // 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);
- }
-
- 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);
+ CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
+ kOuterACone,kOuterBCone,kOuterRadiusCone,
+ kTheta,xshld,yshld);
+
+ 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) ) );
- }
-
- 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));
+ 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) ));
+
+ zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
+ + kHalfLengthRing;
+ vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
+ vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));
for (Int_t i=0; i<4; i++) {
Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
- vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
- kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
- +kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
- vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,
- -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
- -kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
+ vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
+ vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
}
// Some debugging if requested
void AliITSv11GeometrySupport::CreateSPDThermalShape(
Double_t ina, Double_t inb, Double_t inr,
Double_t oua, Double_t oub, Double_t our,
- Double_t t, Double_t *x , Double_t *y )
+ Double_t t, Double_t *x , Double_t *y ) const
{
//
// Creates the proper sequence of X and Y coordinates to determine
//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSPDOmegaShape(
- Double_t *xin, Double_t *yin, Double_t t,
- Double_t d, Double_t *x, Double_t *y)
+ const Double_t *xin, const Double_t *yin, Double_t d,
+ Double_t *x, Double_t *y)
{
//
// Creates the proper sequence of X and Y coordinates to determine
//
// Created: 17 Nov 2007 Mario Sitta
// Updated: 11 Dec 2007 Mario Sitta
+// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one
+// gives erroneous vertexes)
//
- Double_t xlocal[6],ylocal[6];
-
- // First determine various parameters
- Double_t ina = TMath::Sqrt( (xin[23]-xin[0])*(xin[23]-xin[0]) +
- (yin[23]-yin[0])*(yin[23]-yin[0]) );
- Double_t inb = TMath::Sqrt( (xin[ 1]-xin[0])*(xin[ 1]-xin[0]) +
- (yin[ 1]-yin[0])*(yin[ 1]-yin[0]) );
- Double_t inr = yin[0];
- Double_t oua = TMath::Sqrt( (xin[12]-xin[11])*(xin[12]-xin[11]) +
- (yin[12]-yin[11])*(yin[12]-yin[11]) );
- Double_t oub = TMath::Sqrt( (xin[10]-xin[11])*(xin[10]-xin[11]) +
- (yin[10]-yin[11])*(yin[10]-yin[11]) );
- Double_t our = yin[11];
-
- //Create the first inner pseudo-quadrant
- FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
- x[ 1] = xlocal[0];
- y[ 1] = ylocal[0];
-
- x[ 2] = xlocal[1];
- y[ 2] = ylocal[1];
-
- x[ 5] = xlocal[2];
- y[ 5] = ylocal[2];
-
- x[ 6] = xlocal[3];
- y[ 6] = ylocal[3];
-
- x[ 9] = xlocal[4];
- y[ 9] = ylocal[4];
-
- x[10] = xlocal[5];
- y[10] = ylocal[5];
-
- //Create the first outer pseudo-quadrant
- FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
- x[23] = xlocal[0];
- y[23] = ylocal[0];
-
- x[20] = xlocal[1];
- y[20] = ylocal[1];
-
- x[19] = xlocal[2];
- y[19] = ylocal[2];
-
- x[16] = xlocal[3];
- y[16] = ylocal[3];
- x[15] = xlocal[4];
- y[15] = ylocal[4];
+ // This vector contains the index of those points which coincide
+ // with the corresponding points in the air shape
+ Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
- x[11] = xlocal[5];
- y[11] = ylocal[5];
-
- //Create the second inner pseudo-quadrant
- FillSPDXtruShape(ina+2*d,inb-2*d,inr+d,t,xlocal,ylocal);
- x[22] = xlocal[0];
- y[22] = ylocal[0];
-
- x[21] = xlocal[1];
- y[21] = ylocal[1];
+ // First fill those vertexes corresponding to
+ // the edges aligned to the air shape edges
+ for (Int_t j=0; j<12; j++) {
+ x[*(indexAir2Omega+j)] = xin[j];
+ y[*(indexAir2Omega+j)] = yin[j];
+ }
- x[18] = xlocal[2];
- y[18] = ylocal[2];
+ // Now get the coordinates of the first inner point
+ PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
- x[17] = xlocal[3];
- y[17] = ylocal[3];
+ // Knowing this, the second internal point can be determined
+ InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
- x[14] = xlocal[4];
- y[14] = ylocal[4];
+ // The third point is now computable
+ ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
- x[13] = xlocal[5];
- y[13] = ylocal[5];
+ // Repeat this logic
+ InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
- //Create the second outer pseudo-quadrant
- FillSPDXtruShape(oua-2*d,oub+2*d,our-d,t,xlocal,ylocal);
- x[ 0] = xlocal[0];
- y[ 0] = ylocal[0];
+ ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
- x[ 3] = xlocal[1];
- y[ 3] = ylocal[1];
+ InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
- x[ 4] = xlocal[2];
- y[ 4] = ylocal[2];
+ ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
- x[ 7] = xlocal[3];
- y[ 7] = ylocal[3];
+ InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
- x[ 8] = xlocal[4];
- y[ 8] = ylocal[4];
+ ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
- x[12] = xlocal[5];
- y[12] = ylocal[5];
+ InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
// These need to be fixed explicitly
- y[10] = yin[5];
- y[11] = yin[6];
x[12] = x[11];
y[12] = y[11] + d;
x[13] = x[10] + d;
y[13] = y[12];
- // Finally reflex on the negative side
+ // Finally reflect on the negative side
for (Int_t i=0; i<24; i++) {
x[24+i] = -x[23-i];
y[24+i] = y[23-i];
//______________________________________________________________________
void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
Double_t r, Double_t t,
- Double_t *x, Double_t *y)
+ Double_t *x, Double_t *y) const
{
//
// Creates the partial sequence of X and Y coordinates to determine
}
//______________________________________________________________________
-void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
+void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2, Double_t d,
+ Double_t &x, Double_t &y) const
+{
+//
+// Determines the X and Y of the first internal point of the Omega shape
+// (i.e. the coordinates of a point given two parallel lines passing by
+// two points and placed at a known distance)
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/PointFromParallelLines.gif">
+*/
+//End_Html
+
+ // The slope of the paralles lines at a distance d
+ Double_t m;
+
+ // The parameters of the solving equation
+ // a x^2 - 2 b x + c = 0
+ Double_t a = (x1 - x2)*(x1 - x2) - d*d;
+ Double_t b = (x1 - x2)*(y1 - y2);
+ Double_t c = (y1 - y2)*(y1 - y2) - d*d;
+
+ // (delta4 is Delta/4 because we use the reduced formula)
+ Double_t delta4 = b*b - a*c;
+
+ // Compute the slope of the two parallel lines
+ // (one of the two possible slopes, the one with the smaller
+ // absolute value is needed)
+ if (delta4 < 0) { // Should never happen with our data, but just to be sure
+ x = -1; // x is expected positive, so this flags an error
+ return;
+ } else
+ m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data
+
+ // Finally compute the coordinates of the point
+ x = x2 + (y1 - y2 - d)/m;
+ y = y1 - d;
+
+ // Done
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2,
+ Double_t x3, Double_t y3,
+ Double_t &x, Double_t &y) const
+{
+//
+// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
+// lying on the line parallel to the line passing by these points,
+// at a distance d and passing by the point (x3,y3), which is symmetric to
+// the third point with respect to the axis of the segment delimited by
+// the two first points.
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// x3, y3 : third point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the reflected point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/ReflectPoint.gif">
+*/
+//End_Html
+
+ // The slope of the line passing by the first two points
+ Double_t k = (y2 - y1)/(x2 - x1);
+
+ // The middle point of the segment 1-2
+ Double_t xK = (x1 + x2)/2.;
+ Double_t yK = (y1 + y2)/2.;
+
+ // The intercept between the axis of the segment 1-2 and the line
+ // passing by 3 and parallel to the line passing by 1-2
+ Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
+ Double_t yH = k*(xH - x3) + y3;
+
+ // The point symmetric to 3 with respect to H
+ x = 2*xH - x3;
+ y = 2*yH - y3;
+
+ // Done
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
{
//
// Creates the SDD support cone and cylinder geometry as a
// Created: ??? Bjorn S. Nilsen
// Updated: 18 Feb 2008 Mario Sitta
// Updated: 25 Jul 2008 Mario Sitta SDDCarbonFiberCone simpler
+// Updated: 10 Jun 2010 Mario Sitta Cables across cone holes added
//
// Technical data are taken from: "Supporto Generale Settore SDD"
// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
const Double_t kTanConeTheta =
TMath::Tan(kConeTheta*TMath::DegToRad());
// Dimensions of the Cone Inserts
- const Double_t kConeCFThickness = 1.5*fgkmm; // Carbon fiber thickness
+ const Double_t kConeCFThickness = 1.5*fgkmm;//Carbon fiber thickness
// Dimensions of the Cone Holes
const Double_t kHole1RMin = (450.0/2)*fgkmm;
const Double_t kHole1RMax = (530.0/2)*fgkmm;
const Double_t kHole4DeltaR = 15*fgkmm;
const Double_t kHole4Width = 30*fgkmm;
// const Int_t kNHole4 = 3 ;
+ // Fraction of materials in holes
+ const Double_t kHolePlasticFrac = 0.55846;
+ const Double_t kHoleCuFrac = 0.06319;
+ const Double_t kHoleGlassFrac = 0.02652;
// Local variables
Double_t x, y, z, t, dza, rmin, rmax;
// Recover the needed materials
- TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$");
- TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
- TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
- TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
- TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$");
+ TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
+ TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
+ TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
+ TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medSDDCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");
// First define the geometrical shapes
// Mount up the cylinder
for(Int_t i=0; i<kNBolts; i++){
t = kThetaBolt*i;
- x = kBoltRadius*TMath::Cos(t);
- y = kBoltRadius*TMath::Sin(t);
+ x = kBoltRadius*CosD(t);
+ y = kBoltRadius*SinD(t);
z = kFlangeHalfLength-kBoltDepth;
flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
}
hole4shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
hole4shape->GetRmax(3));
+ // Cables to be put inside the holes: Pcon's
+ // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
+ TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+ hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
+ hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
+ hole1plastshape->Z(0) = hole1shape->GetZ(0);
+
+ hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
+ hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
+ hole1plastshape->Z(1) = hole1shape->GetZ(1);
+
+ dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;
+
+ hole1plastshape->Rmin(2) = dza;
+ hole1plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole1plastshape->GetRmin(2));
+ hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
+ hole1plastshape->GetZ(2));
+
+ hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
+ hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
+ hole1plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole1plastshape->GetRmax(3));
+
+ TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+ hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
+ hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
+ hole1Cushape->Z(0) = hole1plastshape->GetZ(2);
+
+ dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;
+
+ hole1Cushape->Rmin(1) = dza;
+ hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
+ hole1Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole1Cushape->GetRmin(1));
+
+ hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
+ hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
+ hole1Cushape->Z(2) = hole1plastshape->GetZ(3);
+
+ hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
+ hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
+ hole1Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole1Cushape->GetRmax(3));
+
+ TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+ hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
+ hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
+ hole1glassshape->Z(0) = hole1Cushape->GetZ(1);
+
+ dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;
+
+ hole1glassshape->Rmin(1) = dza;
+ hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
+ hole1glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole1glassshape->GetRmin(1));
+
+ hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
+ hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
+ hole1glassshape->Z(2) = hole1Cushape->GetZ(3);
+
+ hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
+ hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
+ hole1glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole1glassshape->GetRmax(3));
+ //
+ TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+ hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
+ hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
+ hole2plastshape->Z(0) = hole2shape->GetZ(0);
+
+ hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
+ hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
+ hole2plastshape->Z(1) = hole2shape->GetZ(1);
+
+ dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;
+
+ hole2plastshape->Rmin(2) = dza;
+ hole2plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole2plastshape->GetRmin(2));
+ hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
+ hole2plastshape->GetZ(2));
+
+ hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
+ hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
+ hole2plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole2plastshape->GetRmax(3));
+
+ TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+ hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
+ hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
+ hole2Cushape->Z(0) = hole2plastshape->GetZ(2);
+
+ dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;
+
+ hole2Cushape->Rmin(1) = dza;
+ hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
+ hole2Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole2Cushape->GetRmin(1));
+
+ hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
+ hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
+ hole2Cushape->Z(2) = hole2plastshape->GetZ(3);
+
+ hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
+ hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
+ hole2Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole2Cushape->GetRmax(3));
+
+ TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+ hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
+ hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
+ hole2glassshape->Z(0) = hole2Cushape->GetZ(1);
+
+ dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;
+
+ hole2glassshape->Rmin(1) = dza;
+ hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
+ hole2glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
+ hole2glassshape->GetRmin(1));
+
+ hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
+ hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
+ hole2glassshape->Z(2) = hole2Cushape->GetZ(3);
+
+ hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
+ hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
+ hole2glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
+ hole2glassshape->GetRmax(3));
+
+
// Debug if requested
if (GetDebug(1)) {
coneshape->InspectShape();
hole12->SetFillColor(hole12->GetLineColor());
hole12->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
+ hole1plastshape,medSDDplast);
+ hole1plast->SetVisibility(kTRUE);
+ hole1plast->SetLineColor(kBlue);
+ hole1plast->SetLineWidth(1);
+ hole1plast->SetFillColor(hole1plast->GetLineColor());
+ hole1plast->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
+ hole1Cushape,medSDDCu);
+ hole1Cu->SetVisibility(kTRUE);
+ hole1Cu->SetLineColor(kRed);
+ hole1Cu->SetLineWidth(1);
+ hole1Cu->SetFillColor(hole1Cu->GetLineColor());
+ hole1Cu->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
+ hole1glassshape,medSDDglass);
+ hole1glass->SetVisibility(kTRUE);
+ hole1glass->SetLineColor(kGreen);
+ hole1glass->SetLineWidth(1);
+ hole1glass->SetFillColor(hole1glass->GetLineColor());
+ hole1glass->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
hole2shape,medSDDair);
hole2->SetVisibility(kTRUE);
hole22->SetFillColor(hole22->GetLineColor());
hole22->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
+ hole2plastshape,medSDDplast);
+ hole2plast->SetVisibility(kTRUE);
+ hole2plast->SetLineColor(kBlue);
+ hole2plast->SetLineWidth(1);
+ hole2plast->SetFillColor(hole2plast->GetLineColor());
+ hole2plast->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
+ hole2Cushape,medSDDCu);
+ hole2Cu->SetVisibility(kTRUE);
+ hole2Cu->SetLineColor(kRed);
+ hole2Cu->SetLineWidth(1);
+ hole2Cu->SetFillColor(hole2Cu->GetLineColor());
+ hole2Cu->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
+ hole2glassshape,medSDDglass);
+ hole2glass->SetVisibility(kTRUE);
+ hole2glass->SetLineColor(kGreen);
+ hole2glass->SetLineWidth(1);
+ hole2glass->SetFillColor(hole2glass->GetLineColor());
+ hole2glass->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
hole3shape,medSDDair);
hole3->SetVisibility(kTRUE);
// Mount up a cone
cfconeinsert->AddNode(cfconefoam,1,0);
+ hole1->AddNode(hole1plast, 1, 0);
+ hole1->AddNode(hole1Cu, 1, 0);
+ hole1->AddNode(hole1glass, 1, 0);
+
+ hole2->AddNode(hole2plast, 1, 0);
+ hole2->AddNode(hole2Cu, 1, 0);
+ hole2->AddNode(hole2glass, 1, 0);
+
for (Int_t i=0; i<12; i++) {
Double_t phiH = i*30.0;
cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
}
//______________________________________________________________________
-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
// Updated: 11 Apr 2008 Mario Sitta
// Measures from drawings give overlaps with SPD thermal shield wings,
// so the terminal part of the SSD cone was reduced
+//
+// Updated: 30 Mar 2010 Mario Sitta
+// Following M. van Leeuwen's suggestion on material budget, the thickness
+// 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.6 *fgkmm;
+ const Double_t kCylinderThickness = 0.625*fgkmm;
const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
const Double_t kFoamThickness = 5.0 *fgkmm;
const Double_t kFlangeHalfLength =
vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
for (Int_t i=0; i<4; i++) {
- Double_t thetaW = kThetaWing + 90.*i;
- vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition,
+ Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
+ vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
new TGeoRotation("",thetaW,180,0)));
}
//______________________________________________________________________
void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
TGeoManager *mgr){
- // Define the detail ITS cable support trays on both the RB24 and
- // RB26 sides..
- // Inputs:
- // TGeoVolume *moth The mother volume to place this object.
- // TGeoManager *mgr A pointer to the Geo-Manager default gGeoManager
- // Outputs:
- // none.
- // Return:
- // none.
- // Based on the Drawings SSup_201A.jpg unless otherwise stated,
- // Volumes A...,
- TGeoMedium *medSUPcf = 0; // SUP support cone Carbon Fiber materal nbr.
- TGeoMedium *medSUPfs = 0; // SUP support cone inserto stesalite 4411w.
- TGeoMedium *medSUPfo = 0; // SUP support cone foam, Rohacell 50A.
- TGeoMedium *medSUPss = 0; // SUP support cone screw material,Stainless
- TGeoMedium *medSUPair = 0; // SUP support cone Air
- TGeoMedium *medSUPal = 0; // SUP support cone SDD mounting bracket Al
- TGeoMedium *medSUPwater = 0; // SUP support cone Water
- medSUPcf = mgr->GetMedium("ITSssdCarbonFiber");
- medSUPfs = mgr->GetMedium("ITSssdStaselite4411w");
- medSUPfo = mgr->GetMedium("ITSssdRohacell50A");
- medSUPss = mgr->GetMedium("ITSssdStainlessSteal");
- medSUPair = mgr->GetMedium("ITSssdAir");
- medSUPal = mgr->GetMedium("ITSssdAl");
- medSUPwater = mgr->GetMedium("ITSssdWater");
- //
- Int_t i,j,iRmin;
- Double_t x,y,z,t,t0,dt,di,r,l,local[3],master[3];
- Char_t name[100];
- Double_t r1,r2,m;
- // RB 24, Open Side.
- const Double_t kfrm24Z0 = 900*fgkmm;//SSup_203A.jpg
- const Double_t kfrm24Thss = 5.0*fgkmm;
- const Double_t kfrm24Rss = 444.5*fgkmm-kfrm24Thss; //SSup_204A.jpg
- const Double_t kfrm24Width = 10.0*fgkmm;
- const Double_t kfrm24Hight = 10.0*fgkmm;
- const Double_t kfrm24Phi0 = 15.2*fgkDegree; // SSup_602A.jpg
- const Double_t kfrm24Phi1 = (90.0-7.6)*fgkDegree; // SSup_802A.jpg
- const Double_t kfrm24ZssSection = (415.0-10.0)*fgkmm;
- const Int_t kfrm24NZsections = 4;
- const Int_t kfrm24NPhiSections = 4;
- const Int_t kfrm24NPhi = 4;
- // These numbers are guessed at.
- const Double_t kfrm24ZfracAngle = 0.55; // frational z length to brack
- const Double_t kfrm24Angle = 10.0*fgkDegree; // Guessed at
- //
- TGeoTubeSeg *sA24[kfrm24NZsections+1];
- TGeoArb8 *sB24[kfrm24NZsections+1];
- Double_t zA24[kfrm24NZsections+1];
- l = 4.*kfrm24ZssSection+5*kfrm24Width;
- j = iRmin = 0;
- for(i=0;i<kfrm24NZsections+1;i++){
- sprintf(name,"ITS sup Cable tray support frame radial section A24[%d]",
- i);
- r1 = kfrm24Rss;
- if(i==0) zA24[i] = kfrm24Width;
- else zA24[i] = zA24[i-1] + kfrm24ZssSection + kfrm24Width;
- if(zA24[i]>l*kfrm24ZfracAngle){ // break, radii get larger
- r1 = kfrm24Rss + (zA24[i]-kfrm24ZfracAngle*l)*SinD(kfrm24Angle);
- } // end if
- r2 = r1+kfrm24Thss;
- sA24[i] = new TGeoTubeSeg(name,r1,r2,0.5*kfrm24Width,kfrm24Phi0,
- kfrm24Phi1);
- if(i>0)if(sA24[i-1]->GetRmin()==sA24[i]->GetRmin()) j = iRmin = i;
- } // end for i
- for(i=0;i<kfrm24NZsections;i++){
- sprintf(name,"ITS sup Cable tray support frame Z section B24[%d]",i);
- sB24[i] = new TGeoArb8(name,0.5*kfrm24ZssSection);
- sB24[i]->SetVertex(0,sA24[i]->GetRmin(),0.5*kfrm24Hight);
- sB24[i]->SetVertex(1,sA24[i]->GetRmax(),0.5*kfrm24Hight);
- sB24[i]->SetVertex(2,sA24[i]->GetRmin(),-0.5*kfrm24Hight);
- sB24[i]->SetVertex(3,sA24[i]->GetRmax(),-0.5*kfrm24Hight);
- sB24[i]->SetVertex(4,sA24[i+1]->GetRmin(),0.5*kfrm24Hight);
- sB24[i]->SetVertex(5,sA24[i+1]->GetRmax(),0.5*kfrm24Hight);
- sB24[i]->SetVertex(6,sA24[i+1]->GetRmin(),-0.5*kfrm24Hight);
- sB24[i]->SetVertex(7,sA24[i+1]->GetRmax(),-0.5*kfrm24Hight);
- } // end for i
- if(GetDebug(1)){
- for(i=0;i<kfrm24NZsections+1;i++) sA24[i]->InspectShape();
- for(i=0;i<kfrm24NZsections;i++) sB24[i]->InspectShape();
- } // end if GetDebug(1)
- TGeoVolume *vA24[kfrm24NZsections+1],*vB24[kfrm24NZsections];
- TGeoVolumeAssembly *vM24;
- TGeoTranslation *tran;
- TGeoRotation *rot,*rot1;
- TGeoCombiTrans *tranrot;
- //
- for(i=0;i<kfrm24NZsections+1;i++){
- vA24[i] = 0;
- sprintf(name,"ITSsupFrameA24[%d]",i);
- vA24[i] = new TGeoVolume(name,sA24[i],medSUPss);
- vA24[i]->SetVisibility(kTRUE);
- vA24[i]->SetLineColor(1); // black
- vA24[i]->SetLineWidth(1);
- vA24[i]->SetFillColor(vA24[i]->GetLineColor());
- vA24[i]->SetFillStyle(4000); // 0% transparent
- } // end for i
- for(i=0;i<kfrm24NZsections;i++){
- vB24[i] = 0;
- sprintf(name,"ITSsupFrameB24[%d]",i);
- vB24[i] = new TGeoVolume(name,sB24[i],medSUPss);
- vB24[i]->SetVisibility(kTRUE);
- vB24[i]->SetLineColor(1); // black
- vB24[i]->SetLineWidth(1);
- vB24[i]->SetFillColor(vB24[i]->GetLineColor());
- vB24[i]->SetFillStyle(4000); // 0% transparent
- } // end for i
- vM24 = new TGeoVolumeAssembly("ITSsupFrameM24");
- //vM24->SetVisibility(kTRUE);
- //vM24->SetLineColor(7); // light blue
- //vM24->SetLineWidth(1);
- //vM24->SetFillColor(vM24->GetLineColor());
- //vM24->SetFillStyle(4090); // 90% transparent
- //
- Int_t ncopyB24[kfrm24NPhiSections];
- t0 = kfrm24Phi0;
- dt = (kfrm24Phi1-kfrm24Phi0)/((Double_t)kfrm24NPhiSections);
- for(i=0;i<=kfrm24NZsections;i++){
- z = zA24[i];
- tran = new TGeoTranslation("",0.0,0.0,z);
- vM24->AddNode(vA24[i],1,tran);
- if(i<kfrm24NZsections){
- ncopyB24[i] = 1;
- for(j=0;j<=kfrm24NPhiSections;j++){
- t = t0 + ((Double_t)j)*dt;
- rot = new TGeoRotation("",0.0,0.0,t);
- tranrot = new TGeoCombiTrans("",0.0,0.0,z+sB24[i]->GetDz(),rot);
- //delete rot;// rot not explicity used in AddNode functions.
- vM24->AddNode(vB24[i],ncopyB24[i]++,tranrot);
- } // end for j
- } // end if
- } // end for i
- tran = new TGeoTranslation("",0.0,0.0,kfrm24Z0);
- moth->AddNode(vM24,1,tran);
- for(i=1;i<kfrm24NPhi;i++){
- di = (Double_t) i;
- rot = new TGeoRotation("",0.0,0.0,90.0*di);
- tranrot = new TGeoCombiTrans("",0.0,0.0,kfrm24Z0,rot);
- //delete rot;// rot not explicity used in AddNode functions.
- moth->AddNode(vM24,i+1,tranrot);
- } // end for i
- if(GetDebug(1)){
- for(i=0;i<kfrm24NZsections+1;i++) vA24[i]->PrintNodes();
- for(i=0;i<kfrm24NZsections;i++) vB24[i]->PrintNodes();
- vM24->PrintNodes();
- } // end if
- //==================================================================
- // RB24 Cable Tray
- const Double_t kct24WidthBottom = 44.0*fgkmm; // Serv-C_208.jpg
- const Double_t kct24WidthTop = 46.0*fgkmm; // Serv-C_208.jpg
- const Double_t kct24Hight = 51.0*fgkmm; // Serv-C_208.jpg
- const Double_t kct24AlThick = 1.0*fgkmm; // Serv-C_208.jpg
- const Double_t kct24CapWidth = 46.0*fgkmm; // Serv-C_208.jpg
- const Double_t kct24CapEar = 5.0*fgkmm; // Guess
- const Double_t kct24Rmin = 455.0*fgkmm; // Serv-C_203.jpg
- const Double_t kct24CoolSectionH = 470.0*fgkmm-kct24Rmin;// Serv-C_203.jpg
- const Double_t kct24CoolCableDivEar = 2.0*fgkmm; // Guess
- const Int_t kct24Ntrays = 48; // Serv-C_205.jpg
- //const Int_t kct24Ntubes = 3; // Serv-C_208.jpg
- // Patch Pannels for RB 24 side
- const Double_t kft24PPHightSPDFMD = 72.0*fgkmm; // Serv-C_SPD/FMD.jpg
- const Double_t kft24PPHightSDDSSD = 104.0*fgkmm; // Serv-C_SDD/SSD.jpg
- const Double_t kft24PPlength = 350.0*fgkmm;//Serv-C_SPD/SDD/SSD/FMD_1.jpg
- const Double_t kft24Theta = 2.0*TMath::ATan2(kct24WidthBottom,
- 2.0*kct24Rmin)*fgkRadian; //
- const Int_t kft24NPatchPannels = 20; //
- //
- Double_t xp[12],yp[12];
- TGeoPcon *sMT24;
- TGeoXtru *sT24,*sTs24,*sTl24,*sTt24,*sU24,*sVl24,*sVs24,*sW24;
- TGeoXtru *s3PP24,*s2PP24,*sV3PP24,*sV2PP24;
- // Outer Tray Full
- sT24 = new TGeoXtru(3);
- sT24->SetName("ITS sup Full Cable Tray for RB24 Side T24");
- xp[0] = -0.5*kct24WidthBottom;
- yp[0] = sA24[0]->GetRmax();
- yp[1] = yp[0] + kct24Hight-kct24CapEar;
- xp[1] = Xfrom2Points(xp[0],yp[0],-0.5*kct24WidthTop+kct24AlThick,
- yp[0]+kct24Hight,yp[1]);
- yp[2] = yp[1];
- xp[2] = xp[1]-kct24AlThick;
- xp[3] = -0.5*kct24CapWidth;
- yp[3] = yp[0] + kct24Hight;
- xp[4] = -xp[3];
- yp[4] = yp[3];
- xp[5] = -xp[2];
- yp[5] = yp[2];
- xp[6] = -xp[1];
- yp[6] = yp[1];
- xp[7] = -xp[0];
- yp[7] = yp[0];
- sT24->DefinePolygon(8,xp,yp);
- sT24->DefineSection(0,zA24[0]-kfrm24Width,0.0,0.0,1.0);
- sT24->DefineSection(1,zA24[iRmin],0.0,0.0,1.0);
- sT24->DefineSection(2,zA24[kfrm24NZsections]+kfrm24Width,0.0,
- sA24[kfrm24NZsections]->GetRmax()-sA24[0]->GetRmin());
- // RB 24 full tray no divider (for ALG and T0-V0 cables?)
- sW24 = new TGeoXtru(3);
- sW24->SetName("ITS sup Cable Tray No Divider for RB24 Side W24");
- xp[0] = sT24->GetX(0) + kct24AlThick;
- yp[0] = sT24->GetY(0) + kct24AlThick;
- yp[1] = sT24->GetY(3) - kct24AlThick;
- xp[1] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1),
- sT24->GetY(1),yp[1]) + kct24AlThick;
- xp[2] = -xp[1];
- yp[2] = yp[1];
- xp[3] = -xp[0];
- yp[3] = yp[0];
- sW24->DefinePolygon(4,xp,yp);
- for(i=0;i<sT24->GetNz();i++){
- sW24->DefineSection(i,sT24->GetZ(i),sT24->GetXOffset(i),
- sT24->GetYOffset(i),sT24->GetScale(i));
- } // end for i
- // Outer Tray Short
- sTs24 = new TGeoXtru(3);
- sTs24->SetName("ITS sup Short Cable Tray for RB24 Side Ts24");
- yp[0] = sT24->GetY(0) + kct24CoolSectionH;
- xp[0] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1),
- sT24->GetY(1),yp[0]);
- for(i=1;i<7;i++){
- xp[i] = sT24->GetX(i);
- yp[i] = sT24->GetY(i);
- } // end for i
- xp[7] = -xp[0];
- yp[7] = yp[0];
- sTs24->DefinePolygon(8,xp,yp);
- sTs24->DefineSection(0,zA24[0] -kfrm24Width+kft24PPlength);
- sTs24->DefineSection(1,zA24[iRmin]);
- sTs24->DefineSection(2,zA24[kfrm24NZsections]+kfrm24Width,
- sT24->GetXOffset(2),
- sT24->GetYOffset(2),sT24->GetScale(2));
- // Outer Tray Long
- sTl24 = new TGeoXtru(3);
- sTl24->SetName("ITS sup Long Cable Tray for RB24 Side Tl24");
- for(i=0;i<8;i++){
- xp[i] = sTs24->GetX(i);
- yp[i] = sTs24->GetY(i);
- } // End for i
- sTl24->DefinePolygon(8,xp,yp);
- sTl24->DefineSection(0,zA24[0]-kfrm24Width,0.0,0.0,1.0);
- sTl24->DefineSection(1,zA24[iRmin],0.0,0.0,1.0);
- sTl24->DefineSection(2,zA24[kfrm24NZsections]+kfrm24Width,0.0,
- sA24[kfrm24NZsections]->GetRmax()-sA24[0]->GetRmin(),1.0);
- // Outer Tray for air Tubes
- sTt24 = new TGeoXtru(3);
- sTt24->SetName("ITS sup Long Air Tube Tray for RB24 Side Tt24");
- xp[0] = sT24->GetX(0);
- yp[0] = sT24->GetY(0);
- xp[1] = sTl24->GetX(0);
- yp[1] = sTl24->GetY(0);
- xp[2] = -xp[1];
- yp[2] = yp[1];
- xp[3] = -xp[0];
- yp[3] = yp[0];
- sTt24->DefinePolygon(4,xp,yp);
- sTt24->DefineSection(0,zA24[0]-kfrm24Width,0.0,0.0,1.0);
- sTt24->DefineSection(1,zA24[iRmin],0.0,0.0,1.0);
- sTt24->DefineSection(2,zA24[kfrm24NZsections]+kfrm24Width,0.0,
- sA24[kfrm24NZsections]->GetRmax()-sA24[0]->GetRmin());
- // Inner opening for cooling (lower) {inside sTt24}
- sU24 = new TGeoXtru(3);
- sU24->SetName("ITS sup Cable Tray Cooling tube space RB24 Side U24");
- xp[0] = sTt24->GetX(0) + kct24AlThick;
- yp[0] = sTt24->GetY(0) + kct24AlThick;
- xp[1] = sTt24->GetX(1) + kct24AlThick;
- yp[1] = sTt24->GetY(1) - kct24AlThick;
- xp[2] = -xp[1];
- yp[2] = yp[1];
- xp[3] = -xp[0];
- yp[3] = yp[0];
- sU24->DefinePolygon(4,xp,yp);
- for(i=0;i<sTt24->GetNz();i++){
- sU24->DefineSection(i,sTt24->GetZ(i),sTt24->GetXOffset(i),
- sTt24->GetYOffset(i),sTt24->GetScale(i));
- } // end for i
- // Inner opening for cables (upper) {inside sTl24}
- sVl24 = new TGeoXtru(3);
- sVl24->SetName("ITS sup Cable Tray Cable space RB24 Side Vl24");
- xp[0] = sTl24->GetX(0)+2.0*kct24AlThick;
- yp[0] = sTl24->GetY(0);
- yp[1] = yp[0] + kct24CoolCableDivEar;
- xp[1] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),
- sTl24->GetX(1),sTl24->GetY(1),yp[1])+2.0*kct24AlThick;
- yp[2] = yp[1];
- xp[2] = xp[1] - kct24AlThick;
- yp[3] = sTl24->GetY(3) - kct24AlThick;
- xp[3] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),sTl24->GetX(1),
- sTl24->GetY(1),yp[3]) + kct24AlThick;
- xp[4] = -xp[3];
- yp[4] = yp[3];
- xp[5] = -xp[2];
- yp[5] = yp[2];
- xp[6] = -xp[1];
- yp[6] = yp[1];
- xp[7] = -xp[0];
- yp[7] = yp[0];
- sVl24->DefinePolygon(8,xp,yp);
- for(i=0;i<sTl24->GetNz();i++){
- sVl24->DefineSection(i,sTl24->GetZ(i),sTl24->GetXOffset(i),
- sTl24->GetYOffset(i),sTl24->GetScale(i));
- } // end for i
- // Inner opening for cables (upper) {inside sTs24}
- sVs24 = new TGeoXtru(3);
- sVs24->SetName("ITS sup Cable Tray Cable space RB24 Side Vs24");
- sVs24->DefinePolygon(8,xp,yp);
- for(i=0;i<8;i++){
- xp[i] = sVl24->GetX(i);
- yp[i] = sVl24->GetY(i);
- } // end for i
- for(i=0;i<sTl24->GetNz();i++){
- sVs24->DefineSection(i,sTs24->GetZ(i),sTs24->GetXOffset(i),
- sTs24->GetYOffset(i),sTs24->GetScale(i));
- } // end for i
- //------------------------------------------------------------------
- // Patch Pannels on RB 24 Side
- rot = new TGeoRotation("",0.0,0.0,-kft24Theta); // Gets Used later as well
- rot1 = new TGeoRotation("",0.0,0.0,kft24Theta); // Gets Used later as well
- s3PP24 = new TGeoXtru(2);
- s3PP24->SetName("ITS sup 3 bay pach pannel RB24 side 3PP24");
- yp[5] = sT24->GetY(7) + kct24CoolSectionH;
- xp[5] = Xfrom2Points(sT24->GetX(7),sT24->GetY(7),sT24->GetX(6),
- sT24->GetY(6),yp[6]);
- yp[6] = sT24->GetY(0) + kct24CoolSectionH;
- xp[6] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1),
- sT24->GetY(1),yp[9]);
- local[0] = xp[6]; local[1] = yp[6]; local[2] = 0.0;
- rot1->LocalToMaster(local,master);
- xp[0] = master[0];
- yp[0] = master[1];
- local[0] = xp[6]; local[1] = yp[6] + kft24PPHightSDDSSD; local[2] = 0.0;
- rot1->LocalToMaster(local,master);
- xp[1] = master[0];
- yp[1] = master[1];
- xp[2] = -xp[1];
- yp[2] = yp[1];
- xp[3] = -xp[0];
- yp[3] = yp[0];
- local[0] = xp[6]; local[1] = yp[6]; local[2] = 0.0;
- rot1->MasterToLocal(local,master);
- xp[4] = master[0];
- yp[4] = master[1];
- local[0] = xp[5]; local[1] = yp[5]; local[2] = 0.0;
- rot1->LocalToMaster(local,master);
- xp[7] = master[0];
- yp[7] = master[1];
- s3PP24->DefinePolygon(8,xp,yp);
- s3PP24->DefineSection(0,0.0);
- s3PP24->DefineSection(1,kft24PPlength);
- //
- s2PP24 = new TGeoXtru(2);
- s2PP24->SetName("ITS sup 2 bay pach pannel RB24 side 2PP24");
- local[1] = sTl24->GetY(3); local[2] = 0.0;
- local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),
- sTl24->GetX(1),sTl24->GetY(1),local[1]);
- rot1->LocalToMaster(local,master);
- xp[0] = master[0];
- yp[0] = master[1];
- local[1] = sTl24->GetY(3) + kft24PPHightSPDFMD; local[2] = 0.0;
- local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),
- sTl24->GetX(1),sTl24->GetY(1),local[1]);
- rot1->LocalToMaster(local,master);
- xp[1] = master[0];
- yp[1] = master[1];
- yp[2] = sTl24->GetY(4) + kft24PPHightSPDFMD;
- xp[2] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6),
- sTl24->GetX(7),sTl24->GetY(7),yp[2]);
- yp[3] = sTl24->GetY(7);
- xp[3] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6),
- sTl24->GetX(7),sTl24->GetY(7),yp[3]);
- xp[4] = sTl24->GetX(3);
- yp[4] = sTl24->GetY(3);
- local[0] = sTl24->GetX(4);local[1] = sTl24->GetY(4); local[2] = 0.0;
- rot1->LocalToMaster(local,master);
- xp[5] = master[0];
- yp[5] = master[1];
- s2PP24->DefinePolygon(6,xp,yp);
- s2PP24->DefineSection(0,0.0);
- s2PP24->DefineSection(1,kft24PPlength);
- //
- sV3PP24 = new TGeoXtru(2);
- sV3PP24->SetName("ITS sup Patch Pannel 3 Bay inside Rb24 side V3PP24");
- xp[0] = s3PP24->GetX(0) + kct24AlThick;
- yp[0] = s3PP24->GetY(0) + kct24AlThick;
- local[1] = s3PP24->GetY(6) + kft24PPHightSDDSSD - kct24AlThick;local[2]=0.;
- local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),
- sTl24->GetX(1),sTl24->GetY(1),local[1]);
- rot1->LocalToMaster(local,master);
- xp[1] = master[0];
- yp[1] = master[1];
- xp[2] = -xp[1];
- yp[2] = yp[1];
- xp[3] = -xp[0];
- yp[3] = yp[0];
- xp[4] = s3PP24->GetX(4);
- yp[4] = s3PP24->GetY(4);
- xp[5] = s3PP24->GetX(5);
- yp[5] = s3PP24->GetY(5);
- xp[6] = s3PP24->GetX(6);
- yp[6] = s3PP24->GetY(6);
- xp[7] = s3PP24->GetX(7);
- yp[7] = s3PP24->GetY(7);
- sV3PP24->DefinePolygon(8,xp,yp);
- sV3PP24->DefineSection(0,s3PP24->GetZ(0),s3PP24->GetXOffset(0),
- s3PP24->GetYOffset(0),s3PP24->GetScale(0));
- sV3PP24->DefineSection(1,s3PP24->GetZ(1),s3PP24->GetXOffset(1),
- s3PP24->GetYOffset(1),s3PP24->GetScale(1));
- //
- sV2PP24 = new TGeoXtru(2);
- sV2PP24->SetName("ITS sup Patch Pannel 2 Bay inside Rb24 side V2PP24");
- xp[0] = s2PP24->GetX(0) + kct24AlThick;
- yp[0] = s2PP24->GetY(0) + kct24AlThick;
- local[1] = sTl24->GetY(3) + kft24PPHightSPDFMD - kct24AlThick;local[2]=0.;
- local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),
- sTl24->GetX(1),sTl24->GetY(1),local[1]);
- rot1->LocalToMaster(local,master);
- xp[1] = master[0];
- yp[1] = master[1];
- yp[2] = sTl24->GetY(4) + kft24PPHightSPDFMD - kct24AlThick;
- xp[2] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6),
- sTl24->GetX(7),sTl24->GetY(7),yp[2]);
- yp[3] = sTl24->GetY(4);
- xp[3] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6),
- sTl24->GetX(7),sTl24->GetY(7),yp[3]);;
- xp[4] = s2PP24->GetX(4);
- yp[4] = s2PP24->GetY(4);
- xp[5] = s2PP24->GetX(5);
- yp[5] = s2PP24->GetY(5);
- sV2PP24->DefinePolygon(6,xp,yp);
- sV2PP24->DefineSection(0,s2PP24->GetZ(0),s2PP24->GetXOffset(0),
- s2PP24->GetYOffset(0),s2PP24->GetScale(0));
- sV2PP24->DefineSection(1,s2PP24->GetZ(1),s2PP24->GetXOffset(1),
- s2PP24->GetYOffset(1),s2PP24->GetScale(1));
- // RB 24 Tray Mother Volume
- sMT24 = new TGeoPcon("ITS sup Cable Tray Mother Volume RB24 MT24",
- 0.0,360.0,5);
- sMT24->Z(0) = 0.0;
- sMT24->Rmin(0) = sA24[0]->GetRmax();
- sMT24->Rmax(0) = TMath::Max(TMath::Hypot(s3PP24->GetX(1),s3PP24->GetY(1)),
- TMath::Hypot(s2PP24->GetX(1),s2PP24->GetY(1)));
-
- sMT24->Z(1) = sMT24->GetZ(0) + kft24PPlength;
- sMT24->Rmin(1) = sMT24->GetRmin(0);
- sMT24->Rmax(1) = sMT24->GetRmax(0);
- sMT24->Z(2) = sMT24->GetZ(1);
- sMT24->Rmin(2) = sMT24->GetRmin(0);
- sMT24->Rmax(2) = sMT24->GetRmax(0) - kft24PPHightSPDFMD;
-
- sMT24->Z(3) = sMT24->GetZ(0) + zA24[iRmin] - zA24[0] -kfrm24Width;
- sMT24->Rmin(3) = sA24[iRmin]->GetRmin();
- sMT24->Rmax(3) = TMath::Hypot(sT24->GetX(3),sT24->GetY(3));
- sMT24->Z(4) = sMT24->GetZ(0) + zA24[kfrm24NZsections] + kfrm24Width -
- zA24[0] -kfrm24Width;
- sMT24->Rmin(4) = sA24[kfrm24NZsections]->GetRmax();
- sMT24->Rmax(4) = TMath::Hypot(sT24->GetX(3)+sT24->GetXOffset(2),
- sT24->GetY(3)+sT24->GetYOffset(2));
- //
- if(GetDebug(1)){
- sT24->InspectShape();
- sW24->InspectShape();
- sTl24->InspectShape();
- sTs24->InspectShape();
- sTt24->InspectShape();
- sU24->InspectShape();
- sVl24->InspectShape();
- sVs24->InspectShape();
- s3PP24->InspectShape();
- s2PP24->InspectShape();
- sV3PP24->InspectShape();
- sV2PP24->InspectShape();
- sMT24->InspectShape();
- } // end if GetDebug(1)
- //
- TGeoVolume *vC24[kct24Ntrays],*vT24[kct24Ntrays],*vPP24[kft24NPatchPannels];
- TGeoVolume *vWTV024,*vW24,*vU24,*vUFMD24,*vVl24,*vVlFMD24,*vVs24;
- TGeoVolume *vV3PP24,*vV2PP24,*vV2PPFMD24;
- TGeoVolumeAssembly *vMT24;
- vMT24 = new TGeoVolumeAssembly("ITSsupCableTrayMotherMT24");
- //vMT24->SetVisibility(kTRUE);
- //vMT24->SetLineColor(8); // white
- //vMT24->SetLineWidth(1);
- //vMT24->SetFillColor(vMT24->GetLineColor());
- //vMT24->SetFillStyle(4100); // 100% transparent
- //
- vU24 = new TGeoVolume("ITSsupCableTrayLowerU24",sU24,medSUPair);
- vU24->SetVisibility(kTRUE);
- vU24->SetLineColor(7); // light blue
- vU24->SetLineWidth(1);
- vU24->SetFillColor(vU24->GetLineColor());
- vU24->SetFillStyle(4090); // 90% transparent
- vUFMD24 = new TGeoVolume("FMDsupCableTrayLowerU24",sU24,medSUPair);
- vUFMD24->SetVisibility(kTRUE);
- vUFMD24->SetLineColor(7); // light blue
- vUFMD24->SetLineWidth(1);
- vUFMD24->SetFillColor(vUFMD24->GetLineColor());
- vUFMD24->SetFillStyle(4090); // 90% transparent
- vVl24 = new TGeoVolume("ITSsupCableTrayUpperV24",sVl24,medSUPair);
- vVl24->SetVisibility(kTRUE);
- vVl24->SetLineColor(7); // light blue
- vVl24->SetLineWidth(1);
- vVl24->SetFillColor(vVl24->GetLineColor());
- vVl24->SetFillStyle(4090); // 90% transparent
- vVlFMD24 = new TGeoVolume("FMDsupCableTrayUpperVl24",sVl24,medSUPair);
- vVlFMD24->SetVisibility(kTRUE);
- vVlFMD24->SetLineColor(7); // light blue
- vVlFMD24->SetLineWidth(1);
- vVlFMD24->SetFillColor(vVlFMD24->GetLineColor());
- vVlFMD24->SetFillStyle(4090); // 90% transparent
- vVs24 = new TGeoVolume("ITSsupCableTrayUpperVs24",sVs24,medSUPair);
- vVs24->SetVisibility(kTRUE);
- vVs24->SetLineColor(7); // light blue
- vVs24->SetLineWidth(1);
- vVs24->SetFillColor(vVs24->GetLineColor());
- vVs24->SetFillStyle(4090); // 90% transparent
- vW24 = new TGeoVolume("ITSsupCableTrayUpperW24",sW24,medSUPair);
- vW24->SetVisibility(kTRUE);
- vW24->SetLineColor(7); // light blue
- vW24->SetLineWidth(1);
- vW24->SetFillColor(vW24->GetLineColor());
- vW24->SetFillStyle(4090); // 90% transparent
- //
- vWTV024 = new TGeoVolume("V0supCableTrayUpperWTV024",sW24,medSUPair);
- vWTV024->SetVisibility(kTRUE);
- vWTV024->SetLineColor(7); // light blue
- vWTV024->SetLineWidth(1);
- vWTV024->SetFillColor(vWTV024->GetLineColor());
- vWTV024->SetFillStyle(4090); // 90% transparent
- //
- vV3PP24 = new TGeoVolume("ITSsup3BayPachPannelInsideV3PP24",sV3PP24,medSUPair);
- vV3PP24->SetVisibility(kTRUE);
- vV3PP24->SetLineColor(8); // white
- vV3PP24->SetLineWidth(1);
- vV3PP24->SetFillColor(vV3PP24->GetLineColor());
- vV3PP24->SetFillStyle(4100); // 100% transparent
- vV2PP24 = new TGeoVolume("ITSsup2BayPachPannelInsideV2PP24",sV2PP24,medSUPair);
- vV2PP24->SetVisibility(kTRUE);
- vV2PP24->SetLineColor(8); // white
- vV2PP24->SetLineWidth(1);
- vV2PP24->SetFillColor(vV2PP24->GetLineColor());
- vV2PP24->SetFillStyle(4100); // 100% transparent
- vV2PPFMD24 = new TGeoVolume("FMDsup2BayPachPannelInsideV2PP24",sV2PP24,medSUPair);
- vV2PPFMD24->SetVisibility(kTRUE);
- vV2PPFMD24->SetLineColor(8); // white
- vV2PPFMD24->SetLineWidth(1);
- vV2PPFMD24->SetFillColor(vV2PPFMD24->GetLineColor());
- vV2PPFMD24->SetFillStyle(4100); // 100% transparent
- //
- //delete rot;
- //delete rot1;
- //
- Double_t tha[kct24Ntrays],thb[kft24NPatchPannels];
- for(i=0;i<kct24Ntrays/4;i++) {
- if(i==0) tha[0] = 17.0+0.5*kft24Theta;
- else tha[i] = tha[i-1] + kft24Theta;
- tha[i+ kct24Ntrays/4] = 90.0 + tha[i];
- tha[i+ kct24Ntrays/2] = 180.0 + tha[i];
- tha[i+3*kct24Ntrays/4] = 270.0 + tha[i];
- } // end for i
- if(GetDebug(1)) for(i=0;i<kct24Ntrays;i++) Info("ServicesCableSupport",
- "tha[%d]=%f",i,tha[i]);
- Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
- "TV00","SDD1","SDD2","SPD2","SPD3","ALG0",
- "SPD4","SPD5","SSD2","SSD3","SPD6","SPD7",
- "TV01","SDD3","SDD4","SPD8","SPD9","ALG1",
- "FMD1","SDD5","SSD4","SSD5","SPDA","SPDB",
- "TV02","SDD6","SDD7","SPDC","SPDD","ALG2",
- "SPDE","SPDF","SSD6","SSD7","SPDG","SPDH",
- "TV03","SDD8","SDD9","SPDI","SPDJ","ALG3"};
- Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
- "TV00","SDD0","SDD1","SDD2","SPD1","ALG0",
- "SPD2","SSD4","SSD5","SSD6","SSD7","SPD3",
- "TV01","SDD3","SDD4","SDD5","SPD4","ALG1",
- "FMD1","SSD8","SSD9","SSDA","SSDB","SPD5",
- "TV02","SDD6","SDD7","SDD8","SPD6","ALG2",
- "SPD7","SSDC","SSDD","SSDE","SSDF","SPD8",
- "TV03","SDD9","SDDA","SDDB","SPD9","ALG3"};
- //
- //Int_t ncopyW24=1,ncopyU24=1,ncopyV24=1;
- j = 0;
- for(i=0;i<kct24Ntrays;i++){
- if(strncmp(trayName[i],"FMD",3)==0){
- sprintf(name,"FMDsupCableTrayT24[%s]",trayName[i]);
- vT24[i] = new TGeoVolume(name,sTl24,medSUPal);
- vT24[i]->AddNode(vVlFMD24,1,0);
- }else if(strncmp(trayName[i],"TV0",3)==0){
- sprintf(name,"V0supCableTrayT24[%s]",trayName[i]);
- vT24[i] = new TGeoVolume(name,sT24,medSUPal);
- vT24[i]->AddNode(vWTV024,1,0);
- }else if(strncmp(trayName[i],"ALG",3)==0){ // ITS Alignment Channel
- sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]);
- vT24[i] = new TGeoVolume(name,sT24,medSUPal);
- vT24[i]->AddNode(vW24,1,0);
- }else if(strncmp(trayName[i],"SPD",3)==0){ /*ITS SPD*/
- sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]);
- vT24[i] = new TGeoVolume(name,sTl24,medSUPal);
- vT24[i]->AddNode(vVl24,1,0);
- }else { /*ITS*/
- sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]);
- vT24[i] = new TGeoVolume(name,sTs24,medSUPal); /// replace solid
- vT24[i]->AddNode(vVs24,1,0);
- } // end if
- vT24[i]->SetVisibility(kTRUE);
- vT24[i]->SetLineColor(6); // purple
- vT24[i]->SetLineWidth(1);
- vT24[i]->SetFillColor(vT24[i]->GetLineColor());
- vT24[i]->SetFillStyle(4000); // 0% transparent
- rot = new TGeoRotation("",0.0,0.0,tha[i]-90.0);
- if(GetDebug(1)) rot->Print();
- vMT24->AddNode(vT24[i],1,rot);
- //
- if(strncmp(trayName[i],"FMD",3)==0){
- sprintf(name,"FMDsupAirTubeTrayT24[%s]",airName[i]);
- vC24[j] = new TGeoVolume(name,sTt24,medSUPair);
- vC24[j]->AddNode(vUFMD24,1,0);
- }else if(strncmp(trayName[i],"TV0",3)==0){
- continue;
- }else if(strncmp(trayName[i],"ALG",3)==0){
- continue;
- }else{ /*ITS*/
- sprintf(name,"ITSsupAirTubTrayT24[%s]",airName[i]);
- vC24[j] = new TGeoVolume(name,sTt24,medSUPair);
- vC24[j]->AddNode(vU24,1,0);
- } // end if
- vC24[j]->SetVisibility(kTRUE);
- vC24[j]->SetLineColor(6); // purple
- vC24[j]->SetLineWidth(1);
- vC24[j]->SetFillColor(vC24[j]->GetLineColor());
- vC24[j]->SetFillStyle(4000); // 0% transparent
- vMT24->AddNode(vC24[j++],1,rot);
- } // end for i
- for(i=0;i<kft24NPatchPannels/4;i++) {
- if(i==0) thb[0] = 17.0+0.5*kft24Theta;
- else{
- if(i%2) thb[i] = thb[i-1] + 3.0*kft24Theta;
- else thb[i] = thb[i-1] + 2.0*kft24Theta;
- } // end if-else
- thb[i+ kft24NPatchPannels/4] = 90.0 + thb[i];
- thb[i+ kft24NPatchPannels/2] = 180.0 + thb[i];
- thb[i+3*kft24NPatchPannels/4] = 270.0 + thb[i];
- } // end for i
- Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
- "SPD2","SSD1","SPD3","SDD1","SPD4",
- "FMD1","SSD2","SPD5","SDD2","SPD6",
- "SPD7","SSD3","SPD8","SDD3","SPD9"};
- for(i=0;i<kft24NPatchPannels;i++){
- if(strncmp(pachName[i],"FMD",3)==0){
- sprintf(name,"FMDsupPatchPannelPP24[%s]",pachName[i]);
- vPP24[i] = new TGeoVolume(name,s2PP24,medSUPal);
- vPP24[i]->AddNode(vV2PPFMD24,1,0);
- }else if(strncmp(pachName[i],"SPD",3)==0){ /*ITS SPD*/
- sprintf(name,"ITSsupPathcPannelPP24[%s]",pachName[i]);
- vPP24[i] = new TGeoVolume(name,s2PP24,medSUPal);
- vPP24[i]->AddNode(vV2PP24,1,0);
- }else { /*ITS*/
- sprintf(name,"ITSsupPathcPannelPP24[%s]",pachName[i]);
- vPP24[i] = new TGeoVolume(name,s3PP24,medSUPal); /// replace solid
- vPP24[i]->AddNode(vV3PP24,1,0);
- } // end if
- vPP24[i]->SetVisibility(kTRUE);
- vPP24[i]->SetLineColor(6); // purple
- vPP24[i]->SetLineWidth(1);
- vPP24[i]->SetFillColor(vPP24[i]->GetLineColor());
- vPP24[i]->SetFillStyle(4000); // 0% transparent
- rot = new TGeoRotation("",0.0,0.0,thb[i]-90.0);
- if(GetDebug(1)) rot->Print();
- vMT24->AddNode(vPP24[i],1,rot);
- } // end for i
- tran = new TGeoTranslation("",0.0,0.0,kfrm24Z0);
- moth->AddNode(vMT24,1,tran);
- if(GetDebug(1)){
- for(i=0;i<kct24Ntrays;i++) vT24[i]->PrintNodes();
- for(i=0;i<kct24Ntrays-8;i++) vC24[i]->PrintNodes();
- vU24->PrintNodes();
- vUFMD24->PrintNodes();
- vVl24->PrintNodes();
- vVlFMD24->PrintNodes();
- vVs24->PrintNodes();
- vW24->PrintNodes();
- vWTV024->PrintNodes();
- vMT24->PrintNodes();
- } // end if
- //==================================================================
- //
- // RB 26, Muon Absober side
- const Double_t kfrm26Z0 = -900*fgkmm;//SSup_203A.jpg
- const Double_t kfrm26Thss = 5.0*fgkmm;
- const Double_t kfrm26R0ss = 444.5*fgkmm-kfrm26Thss; //SSup_204A.jpg
- const Double_t kfrm26R1ss = 601.6*fgkmm-kfrm26Thss; //SSup_208A.jpg
- const Double_t kfrm26Width = 10.0*fgkmm;
- //const Double_t kfrm26Hight = 10.0*fgkmm;
- const Double_t kfrm26Phi0 = 15.2*fgkDegree; // SSup_602A.jpg
- const Double_t kfrm26Phi1 = (90.0-7.6)*fgkDegree; // SSup_802A.jpg
- const Double_t kfrm26ZssSection = (415.0-10.0)*fgkmm;
- const Int_t kfrm26NZsections = 4;
- const Int_t kfrm26NPhiSections = 4;
- const Int_t kfrm26NPhi = 4;
- TGeoConeSeg *sA26[kfrm26NZsections+1];//,*sM26;//Cylinderial support structure
- TGeoArb8 *sB26; // Cylinderial support structure
- /*
- sM26 = new TGeoConeSeg("ITS sup Cable tray support frame mother volume "
- "M26",0.5*(4.*kfrm26ZssSection+5*kfrm26Width),
- kfrm26R1ss,kfrm26R1ss+kfrm26Thss,
- kfrm26R0ss,kfrm26R0ss+kfrm26Thss,
- kfrm26Phi0,kfrm26Phi1);
- */
- m = -((kfrm26R1ss-kfrm26R0ss)/
- (((Double_t)kfrm26NZsections)*(kfrm26ZssSection+kfrm26Width)));
- for(i=0;i<kfrm26NZsections+1;i++){
- di = ((Double_t) i)*(kfrm26ZssSection+kfrm26Width);
- sprintf(name,
- "ITS sup Cable tray support frame radial section A26[%d]",i);
- r1 = kfrm26R1ss+m*di;
- r2 = kfrm26R1ss+m*(di+kfrm26Width);
- sA26[i] = new TGeoConeSeg(name,0.5*kfrm26Width,r2,r2+kfrm26Thss,
- r1,r1+kfrm26Thss,kfrm26Phi0,kfrm26Phi1);
- } // end for i
- sB26 = new TGeoArb8("ITS sup Cable tray support frame Z section B26",
- 0.5*kfrm26ZssSection);
- r = 0.25*(sA26[0]->GetRmax1()+sA26[0]->GetRmin1()+
- sA26[1]->GetRmax2()+sA26[1]->GetRmin2());
- sB26->SetVertex(0,sA26[0]->GetRmax2()-r,+0.5*kfrm26Width);
- sB26->SetVertex(1,sA26[0]->GetRmax2()-r,-0.5*kfrm26Width);
- sB26->SetVertex(2,sA26[0]->GetRmin2()-r,-0.5*kfrm26Width);
- sB26->SetVertex(3,sA26[0]->GetRmin2()-r,+0.5*kfrm26Width);
- sB26->SetVertex(4,sA26[1]->GetRmax1()-r,+0.5*kfrm26Width);
- sB26->SetVertex(5,sA26[1]->GetRmax1()-r,-0.5*kfrm26Width);
- sB26->SetVertex(6,sA26[1]->GetRmin1()-r,-0.5*kfrm26Width);
- sB26->SetVertex(7,sA26[1]->GetRmin1()-r,+0.5*kfrm26Width);
- if(GetDebug(1)){
- for(i=0;i<kfrm26NZsections+1;i++) sA26[i]->InspectShape();
- //sM26->InspectShape();
- sB26->InspectShape();
- } // end if GetDebug(1)
- //
- TGeoVolume *vA26[kfrm26NZsections+1],*vB26;
- TGeoVolumeAssembly *vM26;
- //
- for(i=0;i<kfrm26NZsections+1;i++){
- sprintf(name,"ITSsupFrameA26[%d]",i);
- vA26[i] = new TGeoVolume(name,sA26[i],medSUPss);
- vA26[i]->SetVisibility(kTRUE);
- vA26[i]->SetLineColor(1); // black
- vA26[i]->SetLineWidth(1);
- vA26[i]->SetFillColor(vA26[i]->GetLineColor());
- vA26[i]->SetFillStyle(4000); // 0% transparent
- } // end for i
- vB26 = new TGeoVolume("ITSsupFrameB26",sB26,medSUPss);
- vB26->SetVisibility(kTRUE);
- vB26->SetLineColor(1); // black
- vB26->SetLineWidth(1);
- vB26->SetFillColor(vB26->GetLineColor());
- vB26->SetFillStyle(4000); // 0% transparent
- vM26 = new TGeoVolumeAssembly("ITSsupFrameM26");
- //vM26 = new TGeoVolume("ITSsupFrameM26",sM26,medSUPair);
- //vM26->SetVisibility(kTRUE);
- //vM26->SetLineColor(7); // light blue
- //vM26->SetLineWidth(1);
- //vM26->SetFillColor(vM26->GetLineColor());
- //vM26->SetFillStyle(4090); // 90% transparent
- //
- Int_t ncopyB26=1;
- t0 = kfrm26Phi0;
- dt = (kfrm26Phi1-kfrm26Phi0)/((Double_t)kfrm26NPhiSections);
- for(i=0;i<=kfrm26NZsections;i++){
- di = ((Double_t) i)*(kfrm26ZssSection+kfrm26Width);
- z = 0.5*(4.*kfrm26ZssSection+5*kfrm26Width);
- z = -z+sA26[i]->GetDz() + di;
- tran = new TGeoTranslation("",0.0,0.0,z);
- vM26->AddNode(vA26[i],1,tran);
- z = z+sB26->GetDz();
- if(i<kfrm26NZsections)for(j=0;j<=kfrm26NPhiSections;j++){
- r = 0.25*(sA26[i]->GetRmax1()+sA26[i]->GetRmin1()+
- sA26[i+1]->GetRmax2()+sA26[i+1]->GetRmin2());
- t = t0 + ((Double_t)j)*dt;
- rot = new TGeoRotation("",0.0,0.0,t);
- y = r*SinD(t);
- x = r*CosD(t);
- tranrot = new TGeoCombiTrans("",x,y,z,rot);
- //delete rot; // rot not explicity used in AddNode functions.
- vM26->AddNode(vB26,ncopyB26++,tranrot);
- } // end for j
- } // end for i
- tran = new TGeoTranslation("",0.0,0.0,kfrm26Z0-0.5*(4.*kfrm26ZssSection+5*kfrm26Width));
- moth->AddNode(vM26,1,tran);
- for(i=1;i<kfrm26NPhi;i++){
- rot = new TGeoRotation("",0.0,0.0,90.0*((Double_t)i));
- tranrot = new TGeoCombiTrans(*tran,*rot);
- //delete rot; // rot not explicity used in AddNode functions.
- moth->AddNode(vM26,i+1,tranrot);
- } // end for i
- if(GetDebug(1)){
- for(i=0;i<kfrm26NZsections+1;i++) vA26[i]->PrintNodes();
- vB26->PrintNodes();
- vM26->PrintNodes();
- } // end if
+//
+// Creates the cable trays which are outside the ITS support cones
+// but still inside the TPC
+// This is now a stearing routine, the actual work is done by three
+// specialized methods to avoid a really huge unique method
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 15 Nov 2009 Mario Sitta
+//
+
+ TraySupportsSideA(moth, mgr);
+
+ ServicesCableSupportSPD(moth, mgr);
+ ServicesCableSupportSDD(moth, mgr);
+ ServicesCableSupportSSD(moth, mgr);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the structure supporting the ITS cable trays on Side A
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 14 Dec 2009 Mario Sitta
+// Updated: 26 Feb 2010 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 A-Side Cable Tray Support Ring
+ // (0872/G/A/01)
+ const Double_t kSuppRingYTrans = 110.00 *fgkmm;
+ const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm;
+ const Double_t kSuppForwYTrans = 185.00 *fgkmm;
+
+ const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm;
+ const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm;
+ const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm;
+ const Double_t kExtSuppRingBase = 491.50 *fgkmm;
+ const Double_t kExtSuppRingInward = 35.00 *fgkmm;
+ const Double_t kExtSuppRingRmax = 540.00 *fgkmm;
+ const Double_t kExtSuppRingRint1 = 465.00 *fgkmm;
+ const Double_t kExtSuppRingRint2 = 467.00 *fgkmm;
+ const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm;
+ const Double_t kExtSuppRingInWide = 100.00 *fgkmm;
+ const Double_t kExtSuppRingR7 = 7.00 *fgkmm;
+ const Double_t kExtSuppRingR5 = 5.00 *fgkmm;
+ const Double_t kExtSuppRingThick = 20.00 *fgkmm;
+
+ const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad();
+ const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed
+
+ const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc
+
+ const Double_t kIntSuppRingThick1 = 15.00 *fgkmm;
+ const Double_t kIntSuppRingThick2 = 13.00 *fgkmm;
+ const Double_t kIntSuppRingInward = 24.00 *fgkmm;
+ const Double_t kIntSuppRingThick = 20.00 *fgkmm;
+
+ const Double_t kSuppCylHeight = 340.00 *fgkmm;
+ const Double_t kSuppCylRint = 475.00 *fgkmm;
+ const Double_t kSuppCylRext = 478.00 *fgkmm;
+ const Double_t kSuppCylDispl = 137.70 *fgkmm;
+
+ const Double_t kSuppSpacerHeight = 30.00 *fgkmm;
+ const Double_t kSuppSpacerThick = 10.00 *fgkmm;
+
+ const Double_t kSuppSpacerAngle = 15.00; // Degrees
+
+ const Double_t kSuppForwRingRint1 = 500.00 *fgkmm;
+ const Double_t kSuppForwRingRint2 = 540.00 *fgkmm;
+ const Double_t kSuppForwRingRext = 560.00 *fgkmm;
+ const Double_t kSuppForwRingThikAll = 50.00 *fgkmm;
+ const Double_t kSuppForwRingThikInt = 20.00 *fgkmm;
+
+ // (0872/G/B/01)
+ const Double_t kSuppForwConeRmin = 558.00 *fgkmm;
+ const Double_t kSuppForwConeRmax = 681.00 *fgkmm;
+ const Double_t kSuppForwConeLen1 = 318.00 *fgkmm;
+ const Double_t kSuppForwConeLen2 = 662.00 *fgkmm;
+ const Double_t kSuppForwConeThick = 3.00 *fgkmm;
+
+ const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm;
+ const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm;
+ const Double_t kSuppBackRingHeight = 760.00 *fgkmm;
+ const Double_t kSuppBackRingRext = 760.00 *fgkmm;
+ const Double_t kSuppBackRingRint = 685.00 *fgkmm;
+// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm;
+ const Double_t kSuppBackRingR10 = 10.00 *fgkmm;
+ const Double_t kSuppBackRingBase = 739.00 *fgkmm;
+ const Double_t kSuppBackRingThikAll = 50.00 *fgkmm;
+ const Double_t kSuppBackRingThick1 = 20.00 *fgkmm;
+ const Double_t kSuppBackRingThick2 = 20.00 *fgkmm;
+
+// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad();
+ const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp.
+ const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad();
+ const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad();
+
+ const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc
+
+ // (0872/G/C/01)
+ const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm;
+ const Double_t kBackRodZTrans = 2420.00 *fgkmm;
+
+ const Double_t kBackRodLength = 1160.00 *fgkmm;
+ const Double_t kBackRodThickLen = 20.00 *fgkmm;
+ const Double_t kBackRodDiameter = 20.00 *fgkmm;
+
+ const Double_t kSuppRearRingRint = 360.00 *fgkmm;
+ const Double_t kSuppRearRingRext1 = 410.00 *fgkmm;
+ const Double_t kSuppRearRingRext2 = 414.00 *fgkmm;
+ const Double_t kSuppRearRingHeight = 397.00 *fgkmm;
+ const Double_t kSuppRearRingTopWide = 111.87 *fgkmm;
+ const Double_t kSuppRearRingBase = 451.50 *fgkmm;
+ const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm;
+ const Double_t kSuppRearRingSideHi = 52.00 *fgkmm;
+ const Double_t kSuppRearRingInside = 40.00 *fgkmm;
+ const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm;
+ const Double_t kSuppRearRingThick = 20.00 *fgkmm;
+ const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm;
+ const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm;
+
+ const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad();
+ const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad();
+
+ const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc
+
+
+ // Local variables
+ Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
+ Double_t slp1, slp2, phi, xm, ym;
+ Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
+ Int_t npoints;
+
+
+ // The whole support as an assembly
+ TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
+
+
+ // First create all needed shapes
+
+ // The External Ring (part of 0872/G/A/01): a really complex Xtru
+ TGeoXtru *extSuppRing = new TGeoXtru(2);
+
+ // First the upper notch...
+ xprof[ 0] = kExtSuppRingSpace1;
+ yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
+
+ slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
+ IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
+ xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
+
+ xprof[ 4] = xprof[5];
+ yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
+ xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
+ yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6));
+ xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
+ yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3));
+ xprof[ 1] = xprof[4] - kExtSuppRingR5;
+ yprof[ 1] = yprof[4] - kExtSuppRingR5;
+
+ Int_t indx = 5+kExtSuppRingNPtsArc;
+ // ...then the external arc, approximated with segments,...
+ xprof[indx] = kExtSuppRingBase;
+ yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
+ kExtSuppRingBase*kExtSuppRingBase);
+ Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
+ Double_t alphamax = TMath::Pi()/2 -
+ TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
+
+ for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
+ Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
+ xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
+ yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
+ }
+ // ...and finally the interior profile
+ xprof[indx+1] = kExtSuppRingBase;
+ yprof[indx+1] = kSuppRingYTrans;
+ xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
+ yprof[indx+2] = yprof[indx+1];
+
+ phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
+ slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint2*TMath::Cos(phi);
+ ym = kExtSuppRingRint2*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
+ xprof[indx+3], yprof[indx+3]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint1*TMath::Cos(phi);
+ ym = kExtSuppRingRint1*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
+ xprof[indx+4], yprof[indx+4]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint2*TMath::Cos(phi);
+ ym = kExtSuppRingRint2*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
+ xprof[indx+5], yprof[indx+5]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint1*TMath::Cos(phi);
+ ym = kExtSuppRingRint1*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
+ xprof[indx+6], yprof[indx+6]);
+
+ xprof[indx+9] = kExtSuppRingInWide;
+ yprof[indx+9] = kExtSuppRingInnerHi;
+ xprof[indx+8] = xprof[indx+9] +
+ (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
+ yprof[indx+8] = yprof[indx+9] +
+ ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
+ xprof[indx+7] = xprof[indx+9] +
+ (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7;
+ yprof[indx+7] = yprof[indx+9] +
+ ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7;
+ // Gosh, we did the right side! now reflex on the left side
+ npoints = (sizeof(xprof)/sizeof(Double_t))/2;
+ for (Int_t jp = 0; jp < npoints; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-1-jp];
+ yprof[npoints+jp] = yprof[npoints-1-jp];
+ }
+ // wow! now the actual Xtru
+ extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
+ extSuppRing->DefineSection(0,0);
+ extSuppRing->DefineSection(1,kExtSuppRingThick);
+
+ // The Internal Ring (part of 0872/G/A/01): another complex Xtru
+ TGeoXtru *intSuppRing = new TGeoXtru(2);
+
+ // First the external profile...
+ npoints = 0;
+
+ slp1 = 0;
+ phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
+ IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
+ yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
+ xprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = xprof[npoints-1];
+ yprof[npoints] = kSuppRingYTrans;
+ npoints++;
+ // ...and then the interior profile, which is identical to extSuppRing one
+ for (Int_t jp=0; jp < 8; jp++) {
+ xprof[npoints] = extSuppRing->GetX(17+jp);
+ yprof[npoints] = extSuppRing->GetY(17+jp);
+ npoints++;
+ }
+ // We did the right side! now reflex on the left side
+ for (Int_t jp = 0; jp < npoints; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-1-jp];
+ yprof[npoints+jp] = yprof[npoints-1-jp];
+ }
+ // And now the actual Xtru
+ intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
+ intSuppRing->DefineSection(0,0);
+ intSuppRing->DefineSection(1,kIntSuppRingThick);
+
+ // The intermediate cylinder (0872/G/A/03): a TubeSeg
+ alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+ TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
+ kSuppCylHeight/2, alphamin, alphamax);
+
+ // The spacer (0872/G/A/03): a simple Xtru
+ TGeoXtru *suppSpacer = new TGeoXtru(2);
+
+ xprof[0] = kSuppSpacerHeight;
+ yprof[0] = kSuppSpacerThick;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = 0;
+ yprof[2] = 0;
+ xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
+ yprof[3] = yprof[0];
+
+ suppSpacer->DefinePolygon(4, xprof, yprof);
+ suppSpacer->DefineSection(0,-kSuppCylHeight/2);
+ suppSpacer->DefineSection(1, kSuppCylHeight/2);
+
+ // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
+ Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
+ alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+
+ TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
+
+ forwardRing->DefineSection(0,0,
+ kSuppForwRingRint1,kSuppForwRingRext);
+ forwardRing->DefineSection(1,kSuppForwRingThikInt,
+ kSuppForwRingRint1,kSuppForwRingRext);
+ forwardRing->DefineSection(2,kSuppForwRingThikInt,
+ kSuppForwRingRint2,kSuppForwRingRext);
+ forwardRing->DefineSection(3,kSuppForwRingThikAll,
+ kSuppForwRingRint2,kSuppForwRingRext);
+
+ // The forward cone (0872/G/B/03): a TGeoPcon
+ TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
+
+ forwardCone->DefineSection(0,0,
+ kSuppForwConeRmin-kSuppForwConeThick,
+ kSuppForwConeRmin);
+ forwardCone->DefineSection(1,kSuppForwConeLen1,
+ kSuppForwConeRmin-kSuppForwConeThick,
+ kSuppForwConeRmin);
+ forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
+ kSuppForwConeRmax-kSuppForwConeThick,
+ kSuppForwConeRmax);
+
+ // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
+ TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
+
+ // First the external profile... (the arc is approximated with segments)
+ npoints = 0;
+
+ xprof[npoints] = kSuppBackRingPlacTop;
+ yprof[npoints] = kSuppBackRingHeight;
+ npoints++;
+
+ alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
+ alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
+
+ xprof[npoints] = xprof[npoints-1];
+ yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
+ npoints++;
+
+ for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
+ Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
+ xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
+ yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
+ npoints++;
+ }
+
+ xprof[npoints] = kSuppBackRingBase -
+ kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
+ yprof[npoints] = yprof[npoints-1];
+ npoints++;
+
+ xprof[npoints] = kSuppBackRingBase;
+ yprof[npoints] = kSuppForwYTrans;
+ npoints++;
+ // ...then the internal profile (the arc is approximated with segments)
+ alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
+ alphamax = TMath::Pi()/2;
+
+ for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
+ Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
+ xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
+ yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
+ npoints++;
+ }
+
+ xprof[npoints] = 0;
+ yprof[npoints] = kSuppBackRingRint;
+ npoints++;
+ // We did the right side! now reflex on the left side (except last point)
+ for (Int_t jp = 0; jp < npoints-1; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-jp-2];
+ yprof[npoints+jp] = yprof[npoints-jp-2];
+ }
+ // And now the actual Xtru
+ firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
+ firstSuppBackRing->DefineSection(0,0);
+ firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
+
+ // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
+ // (slight oversimplification)
+ alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+
+ TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
+
+ deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
+ rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
+ rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
+ rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
+ rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
+
+ slp1 = TMath::Tan(kSuppBackRing2ndAng2);
+ slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
+ IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
+ slp2,kSuppBackRingThikAll,deltaR,
+ xm, ym);
+
+ zloc = xm - kSuppBackRingThick1;
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR;
+ secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR/2;
+ secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
+
+ // The supporting rod: a Tube
+ TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
+ (kBackRodLength - kBackRodThickLen)/2);
+
+ // The Back Ring (0872/G/C/01): another complex Xtru
+ TGeoXtru *suppRearRing = new TGeoXtru(2);
+
+ // First the external profile...
+ npoints = 0;
+
+ xprof[npoints] = kSuppRearRingTopWide;
+ yprof[npoints] = kSuppRearRingHeight;
+ npoints++;
+
+ phi = kSuppRearRing1stAng;
+ slp1 = TMath::Tan(TMath::Pi() - phi);
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext2*TMath::Sin(phi);
+ ym = kSuppRearRingRext2*TMath::Cos(phi);
+ IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext1*TMath::Sin(phi);
+ ym = kSuppRearRingRext1*TMath::Cos(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext2*TMath::Sin(phi);
+ ym = kSuppRearRingRext2*TMath::Cos(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ slp2 = 0;
+ xm = kSuppRearRingBase;
+ ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = kSuppRearRingBase;
+ yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1];
+ yprof[npoints] = kSuppRearRingBaseHi;
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
+ yprof[npoints] = yprof[npoints - 1];
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1];
+ yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
+ npoints++;
+ // ...then the internal arc, approximated with segments,...
+ xprof[npoints] = kSuppRearRingRint;
+ yprof[npoints] = yprof[npoints - 1];
+
+ alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
+ alphamax = TMath::Pi()/2;
+
+ for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
+ Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
+ xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
+ yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
+ }
+
+ xprof[npoints+kSuppRearRingNPtsArc] = 0;
+ yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
+ // We did the right side! now reflex on the left side
+ Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
+ for (Int_t jp = 0; jp < nTotalPoints; jp++) {
+ xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
+ yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp];
+ }
+
+ // And now the actual Xtru
+ suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
+ suppRearRing->DefineSection(0,0);
+ suppRearRing->DefineSection(1,kSuppRearRingThick);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
+
+ TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
+ extSuppRing, medAl);
+
+ sideAExtSuppRing->SetVisibility(kTRUE);
+ sideAExtSuppRing->SetLineColor(kMagenta+1);
+ sideAExtSuppRing->SetLineWidth(1);
+ sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
+ sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
+ intSuppRing, medAl);
+
+ sideAIntSuppRing->SetVisibility(kTRUE);
+ sideAIntSuppRing->SetLineColor(kMagenta+1);
+ sideAIntSuppRing->SetLineWidth(1);
+ sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
+ sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
+ interCylind, medAl);
+
+ sideASuppCyl->SetVisibility(kTRUE);
+ sideASuppCyl->SetLineColor(kMagenta+1);
+ sideASuppCyl->SetLineWidth(1);
+ sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
+ sideASuppCyl->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
+ suppSpacer, medAl);
+
+ sideASuppSpacer->SetVisibility(kTRUE);
+ sideASuppSpacer->SetLineColor(kMagenta+1);
+ sideASuppSpacer->SetLineWidth(1);
+ sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
+ sideASuppSpacer->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
+ forwardRing, medAl);
+
+ sideASuppForwRing->SetVisibility(kTRUE);
+ sideASuppForwRing->SetLineColor(kMagenta+1);
+ sideASuppForwRing->SetLineWidth(1);
+ sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
+ sideASuppForwRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
+ forwardCone, medAl);
+
+ sideASuppForwCone->SetVisibility(kTRUE);
+ sideASuppForwCone->SetLineColor(kMagenta+1);
+ sideASuppForwCone->SetLineWidth(1);
+ sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
+ sideASuppForwCone->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
+ firstSuppBackRing, medAl);
+
+ sideAFirstSuppBackRing->SetVisibility(kTRUE);
+ sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
+ sideAFirstSuppBackRing->SetLineWidth(1);
+ sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
+ sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
+ secondSuppBackRing, medAl);
+
+ sideASecondSuppBackRing->SetVisibility(kTRUE);
+ sideASecondSuppBackRing->SetLineColor(kMagenta+1);
+ sideASecondSuppBackRing->SetLineWidth(1);
+ sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
+ sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
+ suppRod, medAl);
+
+ sideASuppRod->SetVisibility(kTRUE);
+ sideASuppRod->SetLineColor(kMagenta+1);
+ sideASuppRod->SetLineWidth(1);
+ sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
+ sideASuppRod->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
+ suppRearRing, medAl);
+
+ sideASuppRearRing->SetVisibility(kTRUE);
+ sideASuppRearRing->SetLineColor(kMagenta+1);
+ sideASuppRearRing->SetLineWidth(1);
+ sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
+ sideASuppRearRing->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the support structure
+ zloc = kSuppRingZTrans;
+ trayASuppStruct->AddNode(sideAExtSuppRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAExtSuppRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kExtSuppRingThick;
+ trayASuppStruct->AddNode(sideAIntSuppRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAIntSuppRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ xloc = kExtSuppRingBase - kIntSuppRingInward;
+ yloc = kSuppRingYTrans;
+ zloc += (kIntSuppRingThick + kSuppCylHeight/2);
+ trayASuppStruct->AddNode(sideASuppCyl, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppCyl, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 2,
+ new TGeoCombiTrans(-xloc, yloc, zloc,
+ new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 3,
+ new TGeoCombiTrans( xloc,-yloc, zloc,
+ new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 4,
+ new TGeoCombiTrans(-xloc,-yloc, zloc,
+ new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
+
+
+ zloc += kSuppCylHeight/2;
+ trayASuppStruct->AddNode(sideAIntSuppRing, 3,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAIntSuppRing, 4,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kIntSuppRingThick;
+ trayASuppStruct->AddNode(sideAExtSuppRing, 3,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAExtSuppRing, 4,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kExtSuppRingThick;
+ trayASuppStruct->AddNode(sideASuppForwRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppForwRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kSuppForwRingThikAll;
+ trayASuppStruct->AddNode(sideASuppForwCone, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppForwCone, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
+ trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kSuppBackRingThick1;
+ trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ xloc = kSuppRearRingXRodHole;
+ yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
+ zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
+ trayASuppStruct->AddNode(sideASuppRod, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 3,
+ new TGeoTranslation( xloc,-yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 4,
+ new TGeoTranslation(-xloc,-yloc, zloc) );
+
+ zloc += suppRod->GetDz();
+ trayASuppStruct->AddNode(sideASuppRearRing, 1,
+ new TGeoTranslation( 0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppRearRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+
+ // Finally put everything in the mother volume
+ moth->AddNode(trayASuppStruct,1,0);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the all SPD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 15 Nov 2009 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ SPDCableTraysSideA(moth, mgr);
+ SPDCableTraysSideC(moth, mgr);
+
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the all SDD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 14 Dec 2009 Mario Sitta
+//
+
+ SDDCableTraysSideA(moth, mgr);
+ SDDCableTraysSideC(moth, mgr);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 15 Nov 2009 Mario Sitta
+//
+
+ SSDCableTraysSideA(moth, mgr);
+ SSDCableTraysSideC(moth, mgr);
+
+ return;
}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SPD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 15 Feb 2010 Mario Sitta
+// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello and D.Elia
+// (small differences with blueprints - e.g. -0.07mm in R1Trans and
+// R2Trans - fix small overlaps; they are then compensated in positioning
+// the Rear Tray to avoid its own overlaps with the rear supporting ring)
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
+//
+
+ // Overall position and rotation of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayAR1Trans = 396.93 *fgkmm;
+ const Double_t kTrayAR2Trans = 413.93 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
+ const Double_t kForwardTrayFirstLen = 435.00 *fgkmm;
+ const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+
+ const Int_t kForwardSideNpoints = 6;
+
+ const Double_t kExternalTrayLen = 1200.00 *fgkmm;
+ const Double_t kExternalTrayWide = kForwardTrayWide;
+ const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
+ const Double_t kExternalTrayThick = kForwardTrayThick;
+
+ const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
+
+ const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
+ const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
+ const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
+ const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024*fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695*fgkmm;// Computed
+
+ const Double_t kTrayCCablesRot = 75.000*fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 227.000*fgkmm;// Computed
+
+
+ // Local variables
+ Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
+ Double_t xloc, yloc, zloc, alpharot;
+
+
+ // The two tray components as assemblies
+ TGeoVolumeAssembly *cableTrayAForw =
+ new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
+ TGeoVolumeAssembly *cableTrayAExt =
+ new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
+
+
+ // First create all needed shapes
+
+ // The lower face of the forward tray: a BBox
+ TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ kForwardTrayTotalLen/2);
+
+ // The side face of the forward tray: a Xtru
+ TGeoXtru *forwTraySideFace = new TGeoXtru(2);
+ forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
+
+ xprof[0] = 0;
+ yprof[0] = kForwardTrayThick;
+ xprof[1] = kForwardTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
+ xprof[3] = kForwardTrayFirstLen;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ forwTraySideFace->DefinePolygon(6, xprof, yprof);
+ forwTraySideFace->DefineSection(0, 0);
+ forwTraySideFace->DefineSection(1, kForwardTrayThick);
+
+ // The covers of the forward tray: two BBox's
+ TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ kForwardTrayFirstLen/2);
+
+ TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
+
+ // Each small wing of the forward tray: a BBox
+ TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
+ (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
+ kForwardTrayThick/2);
+
+ // The internal plane of the forward tray: a BBox
+ TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
+ kForwardTrayThick/2,
+ kForwardTrayTotalLen/2);
+
+ // The internal wall of the forward tray: a BBox
+ TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
+ (kForwardTrayInterSpace-kForwardTrayThick)/2,
+ kForwardTrayTotalLen/2);
+
+ // Each horizontal face of the external tray: a BBox
+ TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
+ kExternalTrayThick/2,
+ kExternalTrayLen/2);
+
+ // Each vertical face of the external tray: a BBox
+ TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
+ kExternalTrayHigh/2,
+ kExternalTrayLen/2);
+
+ // The internal wall of the external tray: a BBox
+ TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
+ (kForwardTrayInterSpace-kExternalTrayThick)/2,
+ kExternalTrayLen/2);
+
+ // The cooling tube inside the forward tray: a Tube
+ Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
+ - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
+ Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
+ TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
+
+ // The freon inside the forward tray tubes: a Tube
+ TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
+
+ // The cooling tube inside the external tray: a Ctub
+ TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
+ kExternalTrayLen/2, 0, 360,
+ 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
+ 0, 0, 1);
+
+ // The freon inside the forward tray tubes: a Tube
+ TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
+ kExternalTrayLen/2, 0, 360,
+ 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
+ 0, 0, 1);
+
+ // The optical fibers inside the forward tray: a Xtru
+ TGeoXtru *optFibsForw = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kOpticalFibersSect;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kOpticalFibersSect;
+
+ optFibsForw->DefinePolygon(6, xprof, yprof);
+ optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
+ optFibsForw->DefineSection(1, kOpticalFibersSect/2);
+
+ // The optical fibers inside the external tray: a Xtru
+ TGeoXtru *optFibsExt = new TGeoXtru(2);
+ optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kOpticalFibersSect;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ optFibsExt->DefinePolygon(4, xprof, yprof);
+ optFibsExt->DefineSection(0, 0);
+ optFibsExt->DefineSection(1, kOpticalFibersSect);
+
+ // The Low Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *lowCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;
+
+ lowCablesForwCu->DefinePolygon(6, xprof, yprof);
+ lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);
+
+ TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);
+
+ xprof[0] = lowCablesForwCu->GetX(5);
+ yprof[0] = lowCablesForwCu->GetY(5);
+ xprof[1] = lowCablesForwCu->GetX(4);
+ yprof[1] = lowCablesForwCu->GetY(4);
+ xprof[2] = lowCablesForwCu->GetX(3);
+ yprof[2] = lowCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;
+
+ lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);
+
+ // The Low Voltage inside the external tray: two Xtru
+ TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
+ lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ lowCablesExtCu->DefinePolygon(4, xprof, yprof);
+ lowCablesExtCu->DefineSection(0, 0);
+ lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
+
+ TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
+ lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
+
+ xprof[0] = lowCablesExtCu->GetX(3);
+ yprof[0] = lowCablesExtCu->GetY(3);
+ xprof[1] = lowCablesExtCu->GetX(2);
+ yprof[1] = lowCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ lowCablesExtPUR->DefineSection(0, 0);
+ lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
+
+ // The High Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *hiCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;
+
+ hiCablesForwCu->DefinePolygon(6, xprof, yprof);
+ hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);
+
+ TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesForwCu->GetX(5);
+ yprof[0] = hiCablesForwCu->GetY(5);
+ xprof[1] = hiCablesForwCu->GetX(4);
+ yprof[1] = hiCablesForwCu->GetY(4);
+ xprof[2] = hiCablesForwCu->GetX(3);
+ yprof[2] = hiCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;
+
+ hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);
+
+ // The High Voltage inside the external tray: two Xtru
+ TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
+ hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ hiCablesExtCu->DefinePolygon(4, xprof, yprof);
+ hiCablesExtCu->DefineSection(0, 0);
+ hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
+ hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
+
+ xprof[0] = hiCablesExtCu->GetX(3);
+ yprof[0] = hiCablesExtCu->GetY(3);
+ xprof[1] = hiCablesExtCu->GetX(2);
+ yprof[1] = hiCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ hiCablesExtPUR->DefineSection(0, 0);
+ hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ // The Coaxial cables inside the forward tray: two Xtru
+ TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
+ coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableSectCu/2;
+
+ coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
+ coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");
+
+ xprof[0] = coaxCablesForwCu->GetX(5);
+ yprof[0] = coaxCablesForwCu->GetY(5);
+ xprof[1] = coaxCablesForwCu->GetX(4);
+ yprof[1] = coaxCablesForwCu->GetY(4);
+ xprof[2] = coaxCablesForwCu->GetX(3);
+ yprof[2] = coaxCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableHighMeg/2;
+
+ coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);
+
+ // The Coaxial inside the external tray: two Xtru
+ TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
+ coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoaxCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtCu->DefineSection(0, 0);
+ coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
+
+ TGeoXtru *coaxCablesExtMeg = new TGeoXtru(2);
+ coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");
+
+ xprof[0] = coaxCablesExtCu->GetX(3);
+ yprof[0] = coaxCablesExtCu->GetY(3);
+ xprof[1] = coaxCablesExtCu->GetX(2);
+ yprof[1] = coaxCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoaxCableHighMeg/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtMeg->DefineSection(0, 0);
+ coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
+ TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
+
+ TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
+ forwTrayLowerFace, medAl);
+
+ forwTrayABase->SetVisibility(kTRUE);
+ forwTrayABase->SetLineColor(6); // Purple
+ forwTrayABase->SetLineWidth(1);
+ forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
+ forwTrayABase->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
+ forwTraySideFace, medAl);
+
+ forwTrayASide->SetVisibility(kTRUE);
+ forwTrayASide->SetLineColor(6); // Purple
+ forwTrayASide->SetLineWidth(1);
+ forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
+ forwTrayASide->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
+ forwTrayShortCover, medAl);
+
+ forwTrayACoverShort->SetVisibility(kTRUE);
+ forwTrayACoverShort->SetLineColor(6); // Purple
+ forwTrayACoverShort->SetLineWidth(1);
+ forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
+ forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
+ forwTrayLongCover, medAl);
+
+ forwTrayACoverLong->SetVisibility(kTRUE);
+ forwTrayACoverLong->SetLineColor(6); // Purple
+ forwTrayACoverLong->SetLineWidth(1);
+ forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
+ forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
+ forwTrayWing, medAl);
+
+ forwTrayAWing->SetVisibility(kTRUE);
+ forwTrayAWing->SetLineColor(6); // Purple
+ forwTrayAWing->SetLineWidth(1);
+ forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
+ forwTrayAWing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
+ forwTrayPlane, medAl);
+
+ forwTrayAPlane->SetVisibility(kTRUE);
+ forwTrayAPlane->SetLineColor(6); // Purple
+ forwTrayAPlane->SetLineWidth(1);
+ forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
+ forwTrayAPlane->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
+ forwTrayWall, medAl);
+
+ forwTrayAWall->SetVisibility(kTRUE);
+ forwTrayAWall->SetLineColor(6); // Purple
+ forwTrayAWall->SetLineWidth(1);
+ forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
+ forwTrayAWall->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
+ extTrayHorFace, medAl);
+
+ extTrayAHorFace->SetVisibility(kTRUE);
+ extTrayAHorFace->SetLineColor(6); // Purple
+ extTrayAHorFace->SetLineWidth(1);
+ extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
+ extTrayAHorFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
+ extTrayVerFace, medAl);
+
+ extTrayAVerFace->SetVisibility(kTRUE);
+ extTrayAVerFace->SetLineColor(6); // Purple
+ extTrayAVerFace->SetLineWidth(1);
+ extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
+ extTrayAVerFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
+ extTrayWall, medAl);
+
+ extTrayAWall->SetVisibility(kTRUE);
+ extTrayAWall->SetLineColor(6); // Purple
+ extTrayAWall->SetLineWidth(1);
+ extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
+ extTrayAWall->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
+ coolTubeForw, medIn);
+
+ forwCoolTube->SetVisibility(kTRUE);
+ forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
+ forwCoolTube->SetLineWidth(1);
+ forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
+ forwCoolTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
+ freonTubeForw, medFreon);
+
+ forwCoolFreon->SetVisibility(kTRUE);
+ forwCoolFreon->SetLineColor(kBlue); // Blue
+ forwCoolFreon->SetLineWidth(1);
+ forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
+ forwCoolFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
+ coolTubeExt, medIn);
+
+ extCoolTube->SetVisibility(kTRUE);
+ extCoolTube->SetLineColor(kGray); // as in GeometrySPD
+ extCoolTube->SetLineWidth(1);
+ extCoolTube->SetFillColor(extCoolTube->GetLineColor());
+ extCoolTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
+ freonTubeExt, medFreon);
+
+ extCoolFreon->SetVisibility(kTRUE);
+ extCoolFreon->SetLineColor(kBlue); // Blue
+ extCoolFreon->SetLineWidth(1);
+ extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
+ extCoolFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
+ optFibsForw, medFibs);
+
+ forwOptFibs->SetVisibility(kTRUE);
+ forwOptFibs->SetLineColor(kOrange); // Orange
+ forwOptFibs->SetLineWidth(1);
+ forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
+ forwOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
+ optFibsExt, medFibs);
+
+ extOptFibs->SetVisibility(kTRUE);
+ extOptFibs->SetLineColor(kOrange); // Orange
+ extOptFibs->SetLineWidth(1);
+ extOptFibs->SetFillColor(extOptFibs->GetLineColor());
+ extOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
+ lowCablesForwCu, medCu);
+
+ forwLowCabsCu->SetVisibility(kTRUE);
+ forwLowCabsCu->SetLineColor(kRed); // Red
+ forwLowCabsCu->SetLineWidth(1);
+ forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
+ forwLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
+ lowCablesForwPUR, medPUR);
+
+ forwLowCabsPUR->SetVisibility(kTRUE);
+ forwLowCabsPUR->SetLineColor(kBlack); // Black
+ forwLowCabsPUR->SetLineWidth(1);
+ forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
+ forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
+ lowCablesExtCu, medCu);
+
+ extLowCabsCu->SetVisibility(kTRUE);
+ extLowCabsCu->SetLineColor(kRed); // Red
+ extLowCabsCu->SetLineWidth(1);
+ extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
+ extLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
+ lowCablesExtPUR, medPUR);
+
+ extLowCabsPUR->SetVisibility(kTRUE);
+ extLowCabsPUR->SetLineColor(kBlack); // Black
+ extLowCabsPUR->SetLineWidth(1);
+ extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
+ extLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
+ hiCablesForwCu, medCu);
+
+ forwHiCabsCu->SetVisibility(kTRUE);
+ forwHiCabsCu->SetLineColor(kRed); // Red
+ forwHiCabsCu->SetLineWidth(1);
+ forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
+ forwHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
+ hiCablesForwPUR, medPUR);
+
+ forwHiCabsPUR->SetVisibility(kTRUE);
+ forwHiCabsPUR->SetLineColor(kBlack); // Black
+ forwHiCabsPUR->SetLineWidth(1);
+ forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
+ forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
+ hiCablesExtCu, medCu);
+
+ extHiCabsCu->SetVisibility(kTRUE);
+ extHiCabsCu->SetLineColor(kRed); // Red
+ extHiCabsCu->SetLineWidth(1);
+ extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
+ extHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
+ hiCablesExtPUR, medPUR);
+
+ extHiCabsPUR->SetVisibility(kTRUE);
+ extHiCabsPUR->SetLineColor(kBlack); // Black
+ extHiCabsPUR->SetLineWidth(1);
+ extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
+ extHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
+ coaxCablesForwCu, medCu);
+
+ forwCoaxCu->SetVisibility(kTRUE);
+ forwCoaxCu->SetLineColor(kRed); // Red
+ forwCoaxCu->SetLineWidth(1);
+ forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
+ forwCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
+ coaxCablesForwMeg, medMeg);
+
+ forwCoaxMeg->SetVisibility(kTRUE);
+ forwCoaxMeg->SetLineColor(kBlack); // Black
+ forwCoaxMeg->SetLineWidth(1);
+ forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
+ forwCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
+ coaxCablesExtCu, medCu);
+
+ extCoaxCu->SetVisibility(kTRUE);
+ extCoaxCu->SetLineColor(kRed); // Red
+ extCoaxCu->SetLineWidth(1);
+ extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
+ extCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
+ coaxCablesExtMeg, medMeg);
+
+ extCoaxMeg->SetVisibility(kTRUE);
+ extCoaxMeg->SetLineColor(kBlack); // Black
+ extCoaxMeg->SetLineWidth(1);
+ extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
+ extCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the trays
+ yloc = forwTrayLowerFace->GetDY();
+ zloc = forwTrayLowerFace->GetDZ();
+ cableTrayAForw->AddNode(forwTrayABase, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = kForwardTrayWide/2;
+ cableTrayAForw->AddNode(forwTrayASide, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAForw->AddNode(forwTrayASide, 2,
+ new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
+ zloc = forwTrayShortCover->GetDZ();
+ cableTrayAForw->AddNode(forwTrayACoverShort, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
+ zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
+ cableTrayAForw->AddNode(forwTrayACoverLong, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
+ yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
+ zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc));
+ cableTrayAForw->AddNode(forwTrayAWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc));
+
+ yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
+ zloc = forwTrayPlane->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAPlane, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ yloc = kForwardTrayThick + forwTrayWall->GetDY();
+ zloc = forwTrayWall->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAWall, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ forwCoolTube->AddNode(forwCoolFreon, 1, 0);
+
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
+ + coolTubeForw->GetRmax();
+ zloc = coolTubeForw->GetDz();
+ cableTrayAForw->AddNode(forwCoolTube, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwOptFibs, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwLowCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*lowCablesForwCu->GetZ(1) +
+ hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwHiCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
+ coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwCoaxCu, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ // To simplify following placement in MARS, origin is on top
+ yloc = -kExternalTrayHigh + kExternalTrayThick/2;
+ zloc = kExternalTrayLen/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 1,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
+ yloc = -kExternalTrayHigh/2;
+ cableTrayAExt->AddNode(extTrayAVerFace, 1,
+ new TGeoTranslation( xloc, yloc, zloc));
+ cableTrayAExt->AddNode(extTrayAVerFace, 2,
+ new TGeoTranslation(-xloc, yloc, zloc));
+
+ yloc = -kExternalTrayThick/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 2,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ yloc = -kExternalTrayHigh
+ + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 3,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
+ cableTrayAExt->AddNode(extTrayAWall, 1,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ extCoolTube->AddNode(extCoolFreon, 1, 0);
+
+ yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
+ + coolTubeExt->GetRmax();
+ zloc = coolTubeExt->GetDz();
+ cableTrayAExt->AddNode(extCoolTube, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extOptFibs, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extLowCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extHiCabsCu, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
+ coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extCoaxCu, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+
+ // Finally put everything in the mother volume
+ Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
+
+ moth->AddNode(cableTrayAForw,1,
+ new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
+ moth->AddNode(cableTrayAForw,2,
+ new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans,
+ new TGeoRotation("",180, 0, 0)));
+
+ yloc = kTrayAR1Trans + kExternalTrayHigh;
+ zloc = kTrayAZTrans + kForwardTrayTotalLen;
+ moth->AddNode(cableTrayAExt,1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0)));
+ moth->AddNode(cableTrayAExt,2,
+ new TGeoCombiTrans( 0,-yloc, zloc,
+ new TGeoRotation("",180,-kTrayAZRot, 0)));
+
+ alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,3,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,4,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,5,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,5,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,6,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,6,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,7,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,7,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,8,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,8,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,9,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,9,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,10,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,10,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SPD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Return:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 22 Apr 2010 Mario Sitta
+// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
+// Updated: 20 Dec 2011 Mario Sitta Composite vol to avoid new overlap
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by D.Elia
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
+//
+
+ // Dimensions and positions of the C-Side Cable Tray elements
+ const Int_t kNumTraysSideC = 10;
+
+ const Double_t kTrayCCablesOutRot = 75.000 *fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 245.000 *fgkmm;// Computed
+
+ const Double_t kTrayCHalfWide = 6.350 *fgkcm;
+ const Double_t kTrayCLength1 = 172.800 *fgkcm;
+ const Double_t kTrayCLength2 = 189.300 *fgkcm;
+ const Double_t kTrayCFirstLen = 435.000 *fgkmm;
+ const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCThick = 0.200 *fgkcm;
+ const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
+
+ const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
+ const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
+ const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
+ const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
+ const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024 *fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695 *fgkmm;// Computed
+
+ const Double_t kCablesYtrans = 2.500 *fgkmm;// Avoid ovlps
+
+ // Overall position and rotation of the C-Side Cable Trays
+ const Double_t kTraySideCRPos = 45.300 *fgkcm;
+ const Double_t kTraySideCZPos = -102.400 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] =
+ { 0.0, 41.0, -41.0, 76.0, -76.0};
+ // From position of the other trays
+
+
+ // Local variables
+ Double_t xprof[8], yprof[8];
+ Double_t xloc, yloc, zloc, delta, alpharot;
+
+
+ // The single C-Side Cable tray as an assembly
+ TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");
+
+ // First create all needed shapes
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCHorFace = new TGeoXtru(2);
+ sideCHorFace->SetName("ITSsuppSPDTraySideCHor");
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCHorFace->DefinePolygon(6, xprof, yprof);
+ sideCHorFace->DefineSection(0,-delta);
+ sideCHorFace->DefineSection(1, delta);
+
+ // The Cable Tray middle face: a Xtru
+ // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
+ TGeoXtru *sideCMidFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = kTrayCInterSpace + kTrayCThick;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = yprof[0] + kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCMidFace->DefinePolygon(6, xprof, yprof);
+ sideCMidFace->DefineSection(0,-delta);
+ sideCMidFace->DefineSection(1, delta);
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCSideFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCSecondHigh , xprof[4], yprof[4]);
+ xprof[5] = kTrayCFirstLen;
+ yprof[5] = kTrayCSecondHigh;
+ xprof[6] = xprof[5];
+ yprof[6] = kTrayCFirstHigh;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ sideCSideFace->DefinePolygon(8, xprof, yprof);
+ sideCSideFace->DefineSection(0, 0);
+ sideCSideFace->DefineSection(1, kTrayCThick);
+
+ // The short cover: a BBox
+ TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
+ kTrayCThick/2,
+ kTrayCHalfWide-kTrayCThick);
+
+ // The long cover: a Xtru
+ TGeoXtru *sideCLongCover = new TGeoXtru(2);
+
+ xprof[5] = sideCSideFace->GetX(5);
+ yprof[5] = sideCSideFace->GetY(5);
+ xprof[4] = sideCSideFace->GetX(4);
+ yprof[4] = sideCSideFace->GetY(4);
+ xprof[3] = sideCSideFace->GetX(3);
+ yprof[3] = sideCSideFace->GetY(3);
+ xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
+ -kTrayCThick , xprof[1], yprof[1]);
+ xprof[0] = xprof[5];
+ yprof[0] = yprof[5] - kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCLongCover->DefinePolygon(6, xprof, yprof);
+ sideCLongCover->DefineSection(0,-delta);
+ sideCLongCover->DefineSection(1, delta);
+
+ // The internal wall: a Xtru
+ TGeoXtru *intWall = new TGeoXtru(2);
+ intWall->SetName("ITSsuppSPDTraySideCWall");
+
+ xprof[0] = sideCHorFace->GetX(5);
+ yprof[0] = sideCHorFace->GetY(5);
+ xprof[1] = sideCHorFace->GetX(4);
+ yprof[1] = sideCHorFace->GetY(4);
+ xprof[2] = sideCHorFace->GetX(3);
+ yprof[2] = sideCHorFace->GetY(3);
+ xprof[3] = sideCMidFace->GetX(2);
+ yprof[3] = sideCMidFace->GetY(2);
+ xprof[4] = sideCMidFace->GetX(1);
+ yprof[4] = sideCMidFace->GetY(1);
+ xprof[5] = sideCMidFace->GetX(0);
+ yprof[5] = sideCMidFace->GetY(0);
+
+ intWall->DefinePolygon(6, xprof, yprof);
+ intWall->DefineSection(0,-kTrayCThick/2);
+ intWall->DefineSection(1, kTrayCThick/2);
+
+ // The horizontal part of the cooling tube inside the tray: a Tube
+ delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
+ TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
+
+ // The freon inside the horizontal part of the cooling tube: a Tube
+ TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
+
+ // The inclined part of the cooling tube inside the tray: a Ctub
+ Double_t x3, y3, x4, y4;
+ x3 = sideCMidFace->GetX(3);
+ y3 = sideCMidFace->GetY(3);
+ x4 = sideCMidFace->GetX(4);
+ y4 = sideCMidFace->GetY(4);
+ delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
+ (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) +
+ (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
+ (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
+
+ TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
+ 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
+ 0, 0, 1);
+
+ // The freon inside the inclined part of the cooling tube: a Ctub
+ TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
+ 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
+ 0, 0, 1);
+
+ // The part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
+ 0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
+ // The freon inside the part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
+ outTube->GetDz(),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
+ // The optical fibers inside the tray: a Xtru
+ TGeoXtru *optFibs = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kOpticalFibersSect , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kOpticalFibersSect;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kOpticalFibersSect;
+
+ optFibs->DefinePolygon(8, xprof, yprof);
+ optFibs->DefineSection(0, 0);
+ optFibs->DefineSection(1, kOpticalFibersSect);
+
+ // The low voltage cables inside the tray: two Xtru
+ TGeoXtru *lowCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableSectCu;
+
+ lowCablesCu->DefinePolygon(8, xprof, yprof);
+ lowCablesCu->DefineSection(0, 0);
+ lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
+
+ TGeoXtru *lowCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = lowCablesCu->GetX(7);
+ yprof[0] = lowCablesCu->GetY(7);
+ xprof[1] = lowCablesCu->GetX(6);
+ yprof[1] = lowCablesCu->GetY(6);
+ xprof[2] = lowCablesCu->GetX(5);
+ yprof[2] = lowCablesCu->GetY(5);
+ xprof[3] = lowCablesCu->GetX(4);
+ yprof[3] = lowCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableHighPUR;
+
+ lowCablesPUR->DefinePolygon(8, xprof, yprof);
+ lowCablesPUR->DefineSection(0, 0);
+ lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
+
+ // The high voltage cables inside the tray: two Xtru
+ TGeoXtru *hiCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableSectCu;
+
+ hiCablesCu->DefinePolygon(8, xprof, yprof);
+ hiCablesCu->DefineSection(0, 0);
+ hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
+
+ TGeoXtru *hiCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesCu->GetX(7);
+ yprof[0] = hiCablesCu->GetY(7);
+ xprof[1] = hiCablesCu->GetX(6);
+ yprof[1] = hiCablesCu->GetY(6);
+ xprof[2] = hiCablesCu->GetX(5);
+ yprof[2] = hiCablesCu->GetY(5);
+ xprof[3] = hiCablesCu->GetX(4);
+ yprof[3] = hiCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableHighPUR;
+
+ hiCablesPUR->DefinePolygon(8, xprof, yprof);
+ hiCablesPUR->DefineSection(0, 0);
+ hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
+
+ // The coaxial cables inside the tray: two Xtru
+ TGeoXtru *coaxCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableSectCu;
+
+ coaxCablesCu->DefinePolygon(8, xprof, yprof);
+ coaxCablesCu->DefineSection(0, 0);
+ coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesMeg = new TGeoXtru(2);
+
+ xprof[0] = coaxCablesCu->GetX(7);
+ yprof[0] = coaxCablesCu->GetY(7);
+ xprof[1] = coaxCablesCu->GetX(6);
+ yprof[1] = coaxCablesCu->GetY(6);
+ xprof[2] = coaxCablesCu->GetX(5);
+ yprof[2] = coaxCablesCu->GetY(5);
+ xprof[3] = coaxCablesCu->GetX(4);
+ yprof[3] = coaxCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableHighMeg , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableHighMeg;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableHighMeg;
+
+ coaxCablesMeg->DefinePolygon(8, xprof, yprof);
+ coaxCablesMeg->DefineSection(0, 0);
+ coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);
+
+ // To avoid a newly discovered overlap,
+ // transform the two overlapping volumes into a Composite Shape
+ TGeoCompositeShape *trayIntern =
+ new TGeoCompositeShape("ITSSPDInternalTrayC",
+ "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
+ TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
+
+ TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal",
+ trayIntern, medAl);
+
+ 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);
+
+ traySideCMidFace->SetVisibility(kTRUE);
+ traySideCMidFace->SetLineColor(6); // Purple
+ traySideCMidFace->SetLineWidth(1);
+ traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
+ traySideCMidFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide",
+ sideCSideFace, medAl);
+
+ traySideCSideFace->SetVisibility(kTRUE);
+ traySideCSideFace->SetLineColor(6); // Purple
+ traySideCSideFace->SetLineWidth(1);
+ traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
+ traySideCSideFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov",
+ sideCShortCover, medAl);
+
+ traySideCShortCover->SetVisibility(kTRUE);
+ traySideCShortCover->SetLineColor(6); // Purple
+ traySideCShortCover->SetLineWidth(1);
+ traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
+ traySideCShortCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
+ sideCLongCover, medAl);
+
+ traySideCLongCover->SetVisibility(kTRUE);
+ traySideCLongCover->SetLineColor(6); // Purple
+ traySideCLongCover->SetLineWidth(1);
+ traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
+ traySideCLongCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
+ horTube, medIn);
+
+ traySideCHorTube->SetVisibility(kTRUE);
+ traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCHorTube->SetLineWidth(1);
+ traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
+ traySideCHorTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
+ horFreon, medFr);
+
+ traySideCHorFreon->SetVisibility(kTRUE);
+ traySideCHorFreon->SetLineColor(kBlue); // Blue
+ traySideCHorFreon->SetLineWidth(1);
+ traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
+ traySideCHorFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
+ incTube, medIn);
+
+ traySideCIncTube->SetVisibility(kTRUE);
+ traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCIncTube->SetLineWidth(1);
+ traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
+ traySideCIncTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
+ incFreon, medFr);
+
+ traySideCIncFreon->SetVisibility(kTRUE);
+ traySideCIncFreon->SetLineColor(kBlue); // Blue
+ traySideCIncFreon->SetLineWidth(1);
+ traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
+ traySideCIncFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
+ outTube, medIn);
+
+ traySideCOutTube->SetVisibility(kTRUE);
+ traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCOutTube->SetLineWidth(1);
+ traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
+ traySideCOutTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
+ outFreon, medFr);
+
+ traySideCOutFreon->SetVisibility(kTRUE);
+ traySideCOutFreon->SetLineColor(kBlue); // Blue
+ traySideCOutFreon->SetLineWidth(1);
+ traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
+ traySideCOutFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
+ optFibs, medFibs);
+
+ traySideCOptFibs->SetVisibility(kTRUE);
+ traySideCOptFibs->SetLineColor(kOrange); // Orange
+ traySideCOptFibs->SetLineWidth(1);
+ traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
+ traySideCOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
+ lowCablesCu, medCu);
+
+ traySideCLowCabsCu->SetVisibility(kTRUE);
+ traySideCLowCabsCu->SetLineColor(kRed); // Red
+ traySideCLowCabsCu->SetLineWidth(1);
+ traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
+ traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
+ lowCablesPUR, medPUR);
+
+ traySideCLowCabsPUR->SetVisibility(kTRUE);
+ traySideCLowCabsPUR->SetLineColor(kBlack); // Black
+ traySideCLowCabsPUR->SetLineWidth(1);
+ traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
+ traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
+ hiCablesCu, medCu);
+
+ traySideCHiCabsCu->SetVisibility(kTRUE);
+ traySideCHiCabsCu->SetLineColor(kRed); // Red
+ traySideCHiCabsCu->SetLineWidth(1);
+ traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
+ traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
+ hiCablesPUR, medPUR);
+
+ traySideCHiCabsPUR->SetVisibility(kTRUE);
+ traySideCHiCabsPUR->SetLineColor(kBlack); // Black
+ traySideCHiCabsPUR->SetLineWidth(1);
+ traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
+ traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
+ coaxCablesCu, medCu);
+
+ traySideCCoaxCu->SetVisibility(kTRUE);
+ traySideCCoaxCu->SetLineColor(kRed); // Red
+ traySideCCoaxCu->SetLineWidth(1);
+ traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
+ traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
+ coaxCablesMeg, medMeg);
+
+ traySideCCoaxMeg->SetVisibility(kTRUE);
+ traySideCCoaxMeg->SetLineColor(kBlack); // Black
+ traySideCCoaxMeg->SetLineWidth(1);
+ traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
+ traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the trays
+ cableTrayC->AddNode(traySideCIntern,1,0);
+
+ cableTrayC->AddNode(traySideCMidFace,1,0);
+
+ zloc = kTrayCHalfWide - kTrayCThick;
+ cableTrayC->AddNode(traySideCSideFace, 1,
+ new TGeoTranslation( 0, 0, zloc));
+ zloc = -kTrayCHalfWide;
+ cableTrayC->AddNode(traySideCSideFace, 2,
+ new TGeoTranslation( 0, 0, zloc));
+
+ xloc = sideCShortCover->GetDX();
+ yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
+ cableTrayC->AddNode(traySideCShortCover, 1,
+ new TGeoTranslation( xloc, yloc, 0));
+
+ cableTrayC->AddNode(traySideCLongCover,1,0);
+
+ traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
+ traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
+ traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);
+
+ xloc = horTube->GetDz();
+ yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCHorTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,-90.,90.)));
+
+ xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
+ yloc = sideCMidFace->GetY(4) + incTube->GetRmax() +
+ (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
+ cableTrayC->AddNode(traySideCIncTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
+
+ xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
+ yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
+ 2*outTube->GetRmax();
+ cableTrayC->AddNode(traySideCOutTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-70.,-90.,90.)));
+
+ zloc = horTube->GetRmax();
+ cableTrayC->AddNode(traySideCOptFibs, 1,
+ new TGeoTranslation( 0, 0, zloc));
+
+ zloc = kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCLowCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCLowCabsPUR, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+
+ zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCHiCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCHiCabsPUR, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+
+ zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCCoaxCu, 1,
+ new TGeoTranslation( 0, 0, zloc));
+ cableTrayC->AddNode(traySideCCoaxMeg, 1,
+ new TGeoTranslation( 0, 0, zloc));
+
+
+ // Finally put everything in the mother volume
+ for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(cableTrayC,2*jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
+ alpharot += 180;
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(cableTrayC,2*jt+2,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
+ }
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SDD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 5 Jan 2010 Mario Sitta
+// Updated: 26 Feb 2010 Mario Sitta
+// Updated: 06 Sep 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Overall position and rotation of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayARTrans = 408.35 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
+ const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
+ const Double_t kExternTrayZTrans = 823.00 *fgkmm;
+ const Double_t kExternCoverYTrans = 2.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+ const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
+ const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
+ const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
+ const Double_t kForwardCoverLength = 380.00 *fgkmm;
+ const Double_t kForwardCoverWide = 133.00 *fgkmm;
+ const Double_t kForwardCoverHeight = 10.00 *fgkmm;
+ const Double_t kForwardCoverThick = 1.00 *fgkmm;
+
+ const Double_t kExternTrayTotalLen = 1200.00 *fgkmm;
+ const Double_t kExternTrayTotalHeight = 52.00 *fgkmm;
+ const Double_t kExternCoverLen = kExternTrayTotalLen;
+ const Double_t kExternCoverThick = 5.00 *fgkmm;
+ const Double_t kExternCoverSideThick = 3.00 *fgkmm;
+
+ const Int_t kForwardTrayNpoints = 8;
+
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideACoolManifWide = 8.23 *fgkcm;
+ const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
+ const Double_t kSideACoolManifLen = 3.90 *fgkcm;
+ const Double_t kSideACoolManifPOMFrac = 0.0054;
+ const Double_t kSideACoolManifSteelFrac= 0.8850;
+ const Double_t kSideACoolManifWaterFrac= 0.0913;
+ const Double_t kSideACoolManifAlFrac = 0.0183;
+
+ const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
+ const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
+ const Double_t kSideACoolTubesPURFrac = 0.5897;
+ const Double_t kSideACoolTubesWaterFrac= 0.4101;
+ const Double_t kSideACoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideAOptConnWide = 0.90 *fgkcm;
+ const Double_t kSideAOptConnLen = 1.37 *fgkcm;
+ const Double_t kSideAOptConnPBTFrac = 0.5010;
+ const Double_t kSideAOptConnSteelFrac = 0.1784;
+ const Double_t kSideAOptConnAlFrac = 0.3206;
+
+ const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
+
+ const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
+ const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
+ const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
+ const Double_t kSideAInputCablesCu = 0.7404;
+ const Double_t kSideAInputCablesPlast = 0.1269;
+ const Double_t kSideAInputCablesAl = 0.0057;
+ const Double_t kSideAInputCablesKapton = 0.0172;
+ const Double_t kSideAInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
+ const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
+ const Double_t kSideAOutputCablesCu = 0.6783;
+ const Double_t kSideAOutputCablesPlast = 0.1605;
+ const Double_t kSideAOutputCablesAl = 0.0078;
+ const Double_t kSideAOutputCablesKapton= 0.0232;
+ const Double_t kSideAOutputCablesPOLYAX= 0.1302;
+
+ const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
+ const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
+ const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
+ const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
+ const Double_t kSideAPCBBoardsCu = 0.3864;
+ const Double_t kSideAPCBBoardsEpoxy = 0.1486;
+ const Double_t kSideAPCBBoardsPlast = 0.0578;
+ const Double_t kSideAPCBBoardsSteel = 0.1521;
+ const Double_t kSideAPCBBoardsPPS = 0.2551;
+
+
+ // Local variables
+ Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
+ Double_t xloc, yloc, zloc, alpharot, height;
+
+
+ // The whole tray as an assembly
+ TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
+
+
+ // First create all needed shapes
+
+ // The forward tray is very complex and deserves a dedicated method
+ CreateSDDForwardTraySideA(cableTrayA,mgr);
+
+ // The forward cover: a Xtru
+ TGeoXtru *forwardCover = new TGeoXtru(2);
+ forwardCover->SetName("ITSsuppSDDForwCover");
+
+ xprof[0] = kForwardCoverWide/2;
+ yprof[0] = kForwardCoverHeight;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = xprof[1] - kForwardCoverThick;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[0] - kForwardCoverThick;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ forwardCover->DefinePolygon(8, xprof, yprof);
+ forwardCover->DefineSection(0, 0);
+ forwardCover->DefineSection(1, kForwardCoverLength);
+
+ // The external tray (as 0872/G/D/03): a Xtru
+ TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
+ kExternTrayTotalHeight);
+
+ // The external covers: a Composite Shape
+ TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
+
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifAlFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ // The cooling tubes: three Xtru's
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
+
+ xprof[0] = kSideACoolManifLen;
+ yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
+ xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
+ kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
+ yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
+ kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
+ kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
+ IntersectLines( 0 , xprof[0], yprof[0],
+ TanD(kTrayAZRot), xprof[2], yprof[2],
+ xprof[1], yprof[1]);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
+
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
+
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
+
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
+
+ // The optical fiber connectors: three boxes
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnAlFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = kSideAOptConnLen;
+ yprof[0] = coolTubesPUR->GetY(0);
+ xprof[1] = coolTubesPUR->GetX(1);
+ yprof[1] = coolTubesPUR->GetY(1);
+ xprof[2] = coolTubesPUR->GetX(2);
+ yprof[2] = coolTubesPUR->GetY(2);
+ xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideAOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideAOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
+
+ // The input cables: five boxes
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesCu*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPlast*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesAl*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesKapton*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
+
+ xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
+ forwardCover, medAl);
+
+ forwardTrayCover->SetVisibility(kTRUE);
+ forwardTrayCover->SetLineColor(kMagenta+1); // Purple
+ forwardTrayCover->SetLineWidth(1);
+ forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
+ forwardTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
+ externalTray, medAl);
+
+ externalTraySDD->SetVisibility(kTRUE);
+ externalTraySDD->SetLineColor(6); // Purple
+ externalTraySDD->SetLineWidth(1);
+ externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
+ externalTraySDD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
+ externCover, medAntic);
+
+ externTrayCover->SetVisibility(kTRUE);
+ externTrayCover->SetLineColor(kMagenta+1); // Purple
+ externTrayCover->SetLineWidth(1);
+ externTrayCover->SetFillColor(externTrayCover->GetLineColor());
+ externTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
+ zloc = kForwardTrayUpperLength - kForwardCoverLength;
+ cableTrayA->AddNode(forwardTrayCover, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
+ - kExternCoverYTrans;
+
+ yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternTrayTotalHeight*CosD(kTrayAZRot);
+ zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
+ cableTrayA->AddNode(externalTraySDD, 1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
+
+ yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
+ zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
+ cableTrayA->AddNode(externTrayCover,1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
+
+ yloc = kForwardTrayThick + coolManifPOM->GetDY();
+ zloc = coolManifPOM->GetDZ();
+ cableTrayA->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ cableTrayA->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ cableTrayA->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ cableTrayA->AddNode(alCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(purCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(waterCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(airCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
+ yloc = kForwardTrayThick + optConnPBT->GetDY();
+ zloc = optConnPBT->GetDZ();
+ cableTrayA->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(pbtOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ cableTrayA->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(steelOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ cableTrayA->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(alOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+ xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
+ cableTrayA->AddNode(optFibs,1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(optFibs,2,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
+ kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
+ zloc = inputCabsPOLYAX->GetDZ();
+ cableTrayA->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
+ cableTrayA->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
+ cableTrayA->AddNode(alInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
+ cableTrayA->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
+ cableTrayA->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
+ zloc += pcbBoardsPPS->GetDZ();
+ cableTrayA->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
+ cableTrayA->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
+ cableTrayA->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
+ cableTrayA->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
+ cableTrayA->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(cuOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(plastOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(alOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(kaptonOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(polyaxOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+
+ // Finally put everything in the mother volume
+ Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
+ kExternCoverSideThick -
+ kForwardTrayTailHeight;
+
+ alpharot = -kTrayAFirstRotAng;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
+
+ moth->AddNode(cableTrayA,1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot += 180;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,2,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot += 180;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SDD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 17 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ // Dimensions and positions of the C-Side Cable Tray
+ // (Change accordingly to CreateSDDSSDTraysSideC !)
+ const Int_t kNumTraySideC = 4;
+
+ const Double_t kSideCHalfThick = 0.100 *fgkcm;
+ const Double_t kSideCLength1 = 172.800 *fgkcm;
+ const Double_t kSideCLength2 = 189.300 *fgkcm;
+ const Double_t kBarCoolRmax = 0.4 *fgkcm;
+ const Double_t kXShiftBarCool = 13.00 *fgkcm;
+
+ const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
+
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
+ const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
+ const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
+ const Double_t kSideCCoolManifPOMFrac = 0.0051;
+ const Double_t kSideCCoolManifSteelFrac= 0.8502;
+ const Double_t kSideCCoolManifWaterFrac= 0.0868;
+ const Double_t kSideCCoolManifAlFrac = 0.0579;
+
+ const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
+ const Double_t kSideCCoolTubesPURFrac = 0.5884;
+ const Double_t kSideCCoolTubesWaterFrac= 0.4114;
+ const Double_t kSideCCoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
+ const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
+ const Double_t kSideCOptConnPBTFrac = 0.6798;
+ const Double_t kSideCOptConnSteelFrac = 0.2421;
+ const Double_t kSideCOptConnAlFrac = 0.0781;
+
+ const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
+ const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
+
+ const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
+ const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
+ const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
+ const Double_t kSideCInputCablesCu = 0.7405;
+ const Double_t kSideCInputCablesPlast = 0.1268;
+ const Double_t kSideCInputCablesAl = 0.0057;
+ const Double_t kSideCInputCablesKapton = 0.0172;
+ const Double_t kSideCInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
+ const Double_t kSideCOutputCablesWide = 8.50 *fgkcm;
+ const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
+ const Double_t kSideCOutputCablesCu = 0.6775;
+ const Double_t kSideCOutputCablesPlast = 0.1613;
+ const Double_t kSideCOutputCablesAl = 0.0078;
+ const Double_t kSideCOutputCablesKapton= 0.0234;
+ const Double_t kSideCOutputCablesPOLYAX= 0.1300;
+
+ const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
+ const Double_t kSideCPCBBoardsCu = 0.3864;
+ const Double_t kSideCPCBBoardsEpoxy = 0.1491;
+ const Double_t kSideCPCBBoardsPlast = 0.0579;
+ const Double_t kSideCPCBBoardsSteel = 0.1517;
+ const Double_t kSideCPCBBoardsPPS = 0.2549;
+
+ // Overall position and rotation of the C-Side Cable Trays
+ const Double_t kTraySideCRPos = 45.30 *fgkcm;
+ const Double_t kTraySideCZPos = -102.40 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0,
+ /* from SSD tray position */ 180.-23.0, 180.+59.0};
+
+
+ // Local variables
+ Double_t xprof[6], yprof[6];
+ Double_t height, xloc, yloc, zloc, alpharot, alphafold;
+
+
+ // The assembly holding the metallic structure
+ TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
+
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ // The cooling tubes: three Xtru's
+ alpharot = kSideCFoldAngle*TMath::DegToRad();
+
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
+
+ xprof[0] = 2*kSideCCoolManifHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
+
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
+
+ // The optical fiber connectors: three boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnAlFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = 2*kSideCOptConnHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideCOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideCOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
+
+ // The input cables: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesCu*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPlast*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesAl*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesKapton*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
+
+ xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+ // Now fill the tray
+ xloc = coolManifPOM->GetDX();
+ yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
+ trayStructure->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ trayStructure->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ trayStructure->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ trayStructure->AddNode(alCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ xloc = inputCabsCu->GetDX();
+ yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
+ + kSideCInputCablesTrans;
+ trayStructure->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
+ trayStructure->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
+ trayStructure->AddNode(alInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
+ trayStructure->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
+ trayStructure->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ trayStructure->AddNode(purCoolTubes , 1, 0);
+ trayStructure->AddNode(waterCoolTubes, 1, 0);
+ trayStructure->AddNode(airCoolTubes , 1, 0);
+
+ xloc = optConnPBT->GetDX();
+ yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
+ zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
+ trayStructure->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(pbtOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ trayStructure->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(steelOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ trayStructure->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(alOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ trayStructure->AddNode(optFibs, 1,
+ new TGeoTranslation( 0, 0, zloc) );
+ trayStructure->AddNode(optFibs, 2,
+ new TGeoTranslation( 0, 0,-zloc) );
+
+ trayStructure->AddNode(cuOutputCabs , 1, 0);
+ trayStructure->AddNode(plastOutputCabs , 1, 0);
+ trayStructure->AddNode(alOutputCabs , 1, 0);
+ trayStructure->AddNode(kaptonOutputCabs, 1, 0);
+ trayStructure->AddNode(polyaxOutputCabs, 1, 0);
+
+ xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
+ yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
+ trayStructure->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
+ trayStructure->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
+ trayStructure->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
+ trayStructure->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
+ trayStructure->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+
+ // Finally put everything in the mother volume
+ alphafold = kSideCFoldAngle;
+
+ for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(trayStructure,jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
+ }
+
+
+ return;
+}
+
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 30 Dec 2009 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello and
+// Ton van den Brink
+// Cables and cooling tubes are approximated with proper materials and
+// rectangular cross sections, always preserving the total material budget.
+//
+
+ // Dimensions and positions of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayARTrans = 408.35 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kCoversYTrans = 2.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kTrayTotalHeight = 52.00 *fgkmm;
+ const Double_t kTrayHeighToBend = 32.00 *fgkmm;
+ const Double_t kTrayWidth = 130.00 *fgkmm;
+ const Double_t kTrayThick = 2.00 *fgkmm;
+
+ const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
+
+ const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
+ const Double_t kForwardTrayFirstLen = 350.00 *fgkmm;
+ const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm;
+ const Double_t kForwardCoverLen = 420.00 *fgkmm;
+
+ const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
+ const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!!
+
+ const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm;
+ const Double_t kExternalCoverLen = kExternalTrayTotalLen;
+ const Double_t kExternalCoverThick = 5.00 *fgkmm;
+
+ const Int_t kForwardTrayNpoints = 16;
+
+ const Double_t kServicesWidth = 100.00 *fgkmm;
+ const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
+ 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
+
+
+ // Local variables
+ Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
+ Double_t xloc, yloc, zloc, alpharot, totalhi;
+
+
+ // The two tray components as assemblies
+ TGeoVolumeAssembly *cableTrayAForw =
+ new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
+ TGeoVolumeAssembly *cableTrayAExt =
+ new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
+
+
+ // First create all needed shapes
+
+ // The first part of the forward tray (part of 0872/G/D/07): a Xtru
+ TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
+
+ xprof[3] = kTrayWidth/2;
+ yprof[3] = kForwardTrayFirstHeight;
+ xprof[2] = xprof[3] - kTrayThick;
+ yprof[2] = yprof[3];
+ xprof[4] = xprof[3];
+ yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
+ xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
+ yprof[5] = 0;
+
+ InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
+ -kTrayThick, xprof[1], yprof[1]);
+
+ xprof[6] = -xprof[5];
+ yprof[6] = yprof[5];
+
+ InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
+ -kTrayThick, xprof[0], yprof[0]);
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 6; jp++) {
+ xprof[6+jp] = -xprof[5-jp];
+ yprof[6+jp] = yprof[5-jp];
+ }
+
+ // And now the actual Xtru
+ forwTrayPart1->DefinePolygon(12, xprof, yprof);
+ forwTrayPart1->DefineSection(0, 0);
+ forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
+
+ // The second part of the forward tray (part of 0872/G/D/07): a Xtru
+ TGeoXtru *forwTrayPart2 =
+ CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
+ kTrayTotalHeight);
+
+ // The external tray (as 0872/G/D/03): a Xtru with same profile
+ TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
+ kTrayTotalHeight);
+
+ // The side wall of the forward tray: a BBox
+ TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
+ kForwardSideHeight/2,
+ kForwardSideLength/2);
+
+ // The side cover over the walls: a Xtru
+ TGeoXtru *forwSideCover = new TGeoXtru(2);
+ forwSideCover->SetName("ITSsuppSSDForwCover");
+
+ xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
+ yprof[0] = kForwardCoverHeight;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = xprof[1] - kForwardSideThick;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[0] - kForwardSideThick;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ forwSideCover->DefinePolygon(8, xprof, yprof);
+ forwSideCover->DefineSection(0, 0);
+ forwSideCover->DefineSection(1, kForwardSideLength);
+
+ // The forward and external covers: two Composite Shape's
+ TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
+
+ TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
+
+ // The cable copper inside the forward tray: a BBox
+ TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
+ kCopperHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cable copper inside the forward tray: a Xtru
+ TGeoXtru *extCopper = new TGeoXtru(2);
+ extCopper->SetName("ITSsuppSSDExtTrayCopper");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCopperHeight;
+ totalhi -= kCopperHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extCopper->DefinePolygon(4, xprof, yprof);
+ extCopper->DefineSection(0, 0);
+ extCopper->DefineSection(1, kServicesWidth);
+
+ // The cable plastic inside the forward tray: a BBox
+ TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
+ kCablePlasticHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cable plastic inside the forward tray: a Xtru
+ TGeoXtru *extPlastic = new TGeoXtru(2);
+ extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCablePlasticHeight;
+ totalhi -= kCablePlasticHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extPlastic->DefinePolygon(4, xprof, yprof);
+ extPlastic->DefineSection(0, 0);
+ extPlastic->DefineSection(1, kServicesWidth);
+
+ // The cooling water inside the forward tray: a BBox
+ TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
+ kCoolingWaterHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cooling water inside the forward tray: a Xtru
+ TGeoXtru *extWater = new TGeoXtru(2);
+ extWater->SetName("ITSsuppSSDExtTrayWater");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight - kCablePlasticHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoolingWaterHeight;
+ totalhi -= kCoolingWaterHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extWater->DefinePolygon(4, xprof, yprof);
+ extWater->DefineSection(0, 0);
+ extWater->DefineSection(1, kServicesWidth);
+
+ // The polyurethane inside the forward tray: a BBox
+ TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
+ kPoliUrethaneHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The poliurethane inside the forward tray: a Xtru
+ TGeoXtru *extPUR = new TGeoXtru(2);
+ extPUR->SetName("ITSsuppSSDExtTrayPUR");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight - kCablePlasticHeight
+ - kCoolingWaterHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kPoliUrethaneHeight;
+ totalhi -= kPoliUrethaneHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extPUR->DefinePolygon(4, xprof, yprof);
+ extPUR->DefineSection(0, 0);
+ extPUR->DefineSection(1, kServicesWidth);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
+ TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+
+ TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
+ forwTrayPart1, medAl);
+
+ forwTrayFirst->SetVisibility(kTRUE);
+ forwTrayFirst->SetLineColor(6); // Purple
+ forwTrayFirst->SetLineWidth(1);
+ forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
+ forwTrayFirst->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
+ forwTrayPart2, medAl);
+
+ forwTraySecond->SetVisibility(kTRUE);
+ forwTraySecond->SetLineColor(6); // Purple
+ forwTraySecond->SetLineWidth(1);
+ forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
+ forwTraySecond->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
+ forwSide, medAl);
+
+ forwTraySide->SetVisibility(kTRUE);
+ forwTraySide->SetLineColor(6); // Purple
+ forwTraySide->SetLineWidth(1);
+ forwTraySide->SetFillColor(forwTraySide->GetLineColor());
+ forwTraySide->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
+ forwSideCover, medAl);
+
+ forwTraySideCover->SetVisibility(kTRUE);
+ forwTraySideCover->SetLineColor(6); // Purple
+ forwTraySideCover->SetLineWidth(1);
+ forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
+ forwTraySideCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
+ externalTray, medAl);
+
+ externalTraySSD->SetVisibility(kTRUE);
+ externalTraySSD->SetLineColor(6); // Purple
+ externalTraySSD->SetLineWidth(1);
+ externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
+ externalTraySSD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
+ forwardCover, medAntic);
+
+ forwardTrayCover->SetVisibility(kTRUE);
+ forwardTrayCover->SetLineColor(kMagenta+1); // Purple
+ forwardTrayCover->SetLineWidth(1);
+ forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
+ forwardTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
+ externCover, medAntic);
+
+ externTrayCover->SetVisibility(kTRUE);
+ externTrayCover->SetLineColor(kMagenta+1); // Purple
+ externTrayCover->SetLineWidth(1);
+ externTrayCover->SetFillColor(externTrayCover->GetLineColor());
+ externTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
+ forwCopper, medCu);
+
+ forwCableCu->SetVisibility(kTRUE);
+ forwCableCu->SetLineColor(kRed); // Red
+ forwCableCu->SetLineWidth(1);
+ forwCableCu->SetFillColor(forwCableCu->GetLineColor());
+ forwCableCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
+ extCopper, medCu);
+
+ extCableCu->SetVisibility(kTRUE);
+ extCableCu->SetLineColor(kRed); // Red
+ extCableCu->SetLineWidth(1);
+ extCableCu->SetFillColor(extCableCu->GetLineColor());
+ extCableCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
+ forwPlastic, medFEP);
+
+ forwCableFEP->SetVisibility(kTRUE);
+ forwCableFEP->SetLineColor(kYellow); // Yellow
+ forwCableFEP->SetLineWidth(1);
+ forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
+ forwCableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
+ extPlastic, medFEP);
+
+ extCableFEP->SetVisibility(kTRUE);
+ extCableFEP->SetLineColor(kYellow); // Yellow
+ extCableFEP->SetLineWidth(1);
+ extCableFEP->SetFillColor(extCableFEP->GetLineColor());
+ extCableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
+ forwWater, medH2O);
+
+ forwTrayWater->SetVisibility(kTRUE);
+ forwTrayWater->SetLineColor(kBlue); // Blue
+ forwTrayWater->SetLineWidth(1);
+ forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
+ forwTrayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
+ extWater, medH2O);
+
+ extTrayWater->SetVisibility(kTRUE);
+ extTrayWater->SetLineColor(kBlue); // Blue
+ extTrayWater->SetLineWidth(1);
+ extTrayWater->SetFillColor(extTrayWater->GetLineColor());
+ extTrayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
+ forwPUR, medPUR);
+
+ forwPolyUr->SetVisibility(kTRUE);
+ forwPolyUr->SetLineColor(kGray); // Gray
+ forwPolyUr->SetLineWidth(1);
+ forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
+ forwPolyUr->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
+ extPUR, medPUR);
+
+ extPolyUr->SetVisibility(kTRUE);
+ extPolyUr->SetLineColor(kGray); // Gray
+ extPolyUr->SetLineWidth(1);
+ extPolyUr->SetFillColor(extPolyUr->GetLineColor());
+ extPolyUr->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ cableTrayAForw->AddNode(forwTrayFirst, 1, 0);
+
+ cableTrayAForw->AddNode(forwTraySecond, 1,
+ new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
+
+ xloc = kTrayWidth/2 + kForwardSideThick/2;
+ yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
+ zloc = kForwardSideLength/2;
+ cableTrayAForw->AddNode(forwTraySide,1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayAForw->AddNode(forwTraySide,2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
+ - kForwardCoverHeight;
+ cableTrayAForw->AddNode(forwTraySideCover,1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ yloc = kTrayTotalHeight - kCoversYTrans;
+ zloc = kForwardTrayTotalLen - kForwardCoverLen;
+ cableTrayAForw->AddNode(forwardTrayCover,1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + forwCopper->GetDY();
+ zloc = forwCopper->GetDZ();
+ cableTrayAForw->AddNode(forwCableCu, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
+ zloc = forwPlastic->GetDZ();
+ cableTrayAForw->AddNode(forwCableFEP, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
+ zloc = forwWater->GetDZ();
+ cableTrayAForw->AddNode(forwTrayWater, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
+ + kCoolingWaterHeight + forwPUR->GetDY();
+ zloc = forwPUR->GetDZ();
+ cableTrayAForw->AddNode(forwPolyUr, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ // To simplify following placement in MARS, origin is on top
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
+
+ yloc = -totalhi;
+ cableTrayAExt->AddNode(externalTraySSD, 1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
+ cableTrayAExt->AddNode(externTrayCover,1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ xloc = extCopper->GetDZ();
+ yloc = -totalhi;
+ cableTrayAExt->AddNode(extCableCu,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extPlastic->GetDZ();
+ yloc = -totalhi + kCopperHeight;
+ cableTrayAExt->AddNode(extCableFEP,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extWater->GetDZ();
+ yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
+ cableTrayAExt->AddNode(extTrayWater,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extPUR->GetDZ();
+ yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
+ cableTrayAExt->AddNode(extPolyUr,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+
+ // Finally put everything in the mother volume
+ zloc = kTrayAZTrans;
+ Double_t zlocext = zloc + kForwardTrayTotalLen;
+ Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
+
+ alpharot = kTrayAFirstRotAng;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,1,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,2,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,2,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,3,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,4,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 15 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ // Dimensions and positions of the C-Side Cable Tray elements
+ const Int_t kNumTraySideC = 4;
+
+ const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
+
+ const Double_t kServicesWidth = 100.00 *fgkmm;
+ const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
+ 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;
+ const Double_t kTraySideCZPos = -102.40 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0,
+ /* from Patch panel position */ 180.+23.0, 180.-59.0};
+
+
+ // Local variables
+ Double_t xprof[6], yprof[6];
+ Double_t xloc, yloc, alpharot, alphafold;
+
+
+ // The assembly holding the metallic structure
+ TGeoVolumeAssembly *trayStructure =
+ CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");
+
+ // The cable copper inside the tray: a Xtru
+ TGeoXtru *copper = new TGeoXtru(2);
+ copper->SetName("ITSsuppSSDTrayCCopper");
+
+ // 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) + kCablesYtrans;
+ xprof[1] = lowerplate->GetX(4);
+ yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
+ xprof[2] = lowerplate->GetX(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],
+ kCopperHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCopperHeight;
+
+ copper->DefinePolygon(6, xprof, yprof);
+ copper->DefineSection(0, -kServicesWidth/2);
+ copper->DefineSection(1, kServicesWidth/2);
+
+ // The cable plastic inside the tray: a Xtru
+ TGeoXtru *plastic = new TGeoXtru(2);
+ plastic->SetName("ITSsuppSSDTrayCPlastic");
+
+ xprof[0] = copper->GetX(5);
+ yprof[0] = copper->GetY(5);
+ xprof[1] = copper->GetX(4);
+ yprof[1] = copper->GetY(4);
+ xprof[2] = copper->GetX(3);
+ yprof[2] = copper->GetY(3);
+ xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kCablePlasticHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCablePlasticHeight;
+
+ plastic->DefinePolygon(6, xprof, yprof);
+ plastic->DefineSection(0, -kServicesWidth/2);
+ plastic->DefineSection(1, kServicesWidth/2);
+
+ // The cooling water inside the tray: a Xtru
+ TGeoXtru *water = new TGeoXtru(2);
+ water->SetName("ITSsuppSSDTrayCWater");
+
+ xprof[0] = plastic->GetX(5);
+ yprof[0] = plastic->GetY(5);
+ xprof[1] = plastic->GetX(4);
+ yprof[1] = plastic->GetY(4);
+ xprof[2] = plastic->GetX(3);
+ yprof[2] = plastic->GetY(3);
+ xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kCoolingWaterHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoolingWaterHeight;
+
+ water->DefinePolygon(6, xprof, yprof);
+ water->DefineSection(0, -kServicesWidth/2);
+ water->DefineSection(1, kServicesWidth/2);
+
+ // The poliurethane inside the tray: a Xtru
+ TGeoXtru *pur = new TGeoXtru(2);
+ pur->SetName("ITSsuppSSDTrayCPUR");
+ xprof[0] = water->GetX(5);
+ yprof[0] = water->GetY(5);
+ xprof[1] = water->GetX(4);
+ yprof[1] = water->GetY(4);
+ xprof[2] = water->GetX(3);
+ yprof[2] = water->GetY(3);
+ xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPoliUrethaneHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kPoliUrethaneHeight;
+
+ pur->DefinePolygon(6, xprof, yprof);
+ pur->DefineSection(0, -kServicesWidth/2);
+ pur->DefineSection(1, kServicesWidth/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
+ TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+
+ TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
+ copper, medCu);
+
+ copperCable->SetVisibility(kTRUE);
+ copperCable->SetLineColor(kRed); // Red
+ copperCable->SetLineWidth(1);
+ copperCable->SetFillColor(copperCable->GetLineColor());
+ copperCable->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
+ plastic, medFEP);
+
+ cableFEP->SetVisibility(kTRUE);
+ cableFEP->SetLineColor(kYellow); // Yellow
+ cableFEP->SetLineWidth(1);
+ cableFEP->SetFillColor(cableFEP->GetLineColor());
+ cableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
+ water, medH2O);
+
+ trayWater->SetVisibility(kTRUE);
+ trayWater->SetLineColor(kBlue); // Blue
+ trayWater->SetLineWidth(1);
+ trayWater->SetFillColor(trayWater->GetLineColor());
+ trayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
+ pur, medPUR);
+
+ trayPolyUr->SetVisibility(kTRUE);
+ trayPolyUr->SetLineColor(kGray); // Gray
+ trayPolyUr->SetLineWidth(1);
+ trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
+ trayPolyUr->SetFillStyle(4000); // 0% transparent
+
+
+ // Now fill in the tray
+ trayStructure->AddNode(copperCable,1,0);
+ trayStructure->AddNode(cableFEP,1,0);
+ trayStructure->AddNode(trayWater,1,0);
+ trayStructure->AddNode(trayPolyUr,1,0);
+
+
+ // Finally put everything in the mother volume
+ alphafold = kSideCFoldAngle;
+
+ for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(trayStructure,jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
+ }
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
+ const TGeoManager *mgr){
+//
+// Creates the forward SDD tray on Side A (0872/G/D/01)
+//
+// Input:
+// tray : the TGeoVolumeAssembly to put the elements in
+// mgr : the GeoManager (used only to get the proper material)
+//
+// Output:
+//
+// Return:
+//
+// Created: 08 Jan 2010 Mario Sitta
+// Updated: 07 Sep 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+ const Double_t kForwardTraySideLength = 823.00 *fgkmm;
+ const Double_t kForwardTrayTailLength = 212.00 *fgkmm;
+ const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm;
+ const Double_t kForwardTrayNotchLength = 47.20 *fgkmm;
+ const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm;
+ const Double_t kForwardTrayNotchDown = 10.00 *fgkmm;
+ const Double_t kForwardTraySide1Height = 39.00 *fgkmm;
+ const Double_t kForwardTraySide2Height = 26.00 *fgkmm;
+ const Double_t kForwardTraySide2Expand = 10.50 *fgkmm;
+ const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm;
+ const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm;
+ const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm;
+ const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm;
+ const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm;
+ const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm;
+
+ const Int_t kForwardTraySideNpoints = 9;
+
+
+ // Local variables
+ Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
+ Double_t ylen, zlen;
+ Double_t xloc, yloc, zloc;
+
+
+ // The tray has a very complex shape, so it is made by assembling
+ // different elements (with some small simplifications)
+
+ // The tray base: a BBox
+ zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
+ TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
+ kForwardTrayThick/2, zlen);
+
+ // The first part of the side wall: a Xtru
+ TGeoXtru *traySide1 = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = kForwardTrayThick;
+ xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
+ yprof[1] = yprof[0];
+ xprof[2] = kForwardTraySideLength;
+ yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
+ xprof[3] = 0;
+ yprof[3] = yprof[2];
+
+ traySide1->DefinePolygon(4, xprof, yprof);
+ traySide1->DefineSection(0, 0);
+ traySide1->DefineSection(1, kForwardTrayThick);
+
+ // The second part of the side wall: a Xtru
+ TGeoXtru *traySide2 = new TGeoXtru(2);
+
+ xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
+ yprof[0] = traySide1->GetY(2);
+ xprof[1] = kForwardTrayBaseHalfWide;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kForwardTraySide2Expand;
+ yprof[2] = yprof[1] + kForwardTraySide2Height;
+ xprof[3] = xprof[2] - kForwardTrayThick;
+ yprof[3] = yprof[2];
+
+ traySide2->DefinePolygon(4, xprof, yprof);
+ traySide2->DefineSection(0, 0);
+ traySide2->DefineSection(1, kForwardTraySideLength);
+
+ // The third part of the side wall: a Xtru
+ TGeoXtru *traySide3 = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = traySide2->GetY(2);
+ xprof[1] = kForwardTraySideLength;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
+ xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
+ xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[5] - kForwardTrayNotchHeight;
+ xprof[7] = xprof[6] + kForwardTrayNotchLength;
+ yprof[7] = yprof[6];
+ xprof[8] = xprof[7];
+ yprof[8] = yprof[7] - kForwardTrayNotchDown;
+
+ traySide3->DefinePolygon(9, xprof, yprof);
+ traySide3->DefineSection(0, 0);
+ traySide3->DefineSection(1, kForwardTrayThick);
+
+ // The horizontal wing: a BBox
+ TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
+ kForwardTrayThick/2,
+ kForwardTraySide3TailLen/2);
+
+ // The vertical wing: a BBox
+ ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
+ TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
+ ylen, kForwardTrayThick/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+
+ TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
+ trayBase, medAl);
+
+ forwTrayBase->SetVisibility(kTRUE);
+ forwTrayBase->SetLineColor(6); // Purple
+ forwTrayBase->SetLineWidth(1);
+ forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
+ forwTrayBase->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
+ traySide1, medAl);
+
+ forwTraySide1->SetVisibility(kTRUE);
+ forwTraySide1->SetLineColor(6); // Purple
+ forwTraySide1->SetLineWidth(1);
+ forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
+ forwTraySide1->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
+ traySide2, medAl);
+
+ forwTraySide2->SetVisibility(kTRUE);
+ forwTraySide2->SetLineColor(6); // Purple
+ forwTraySide2->SetLineWidth(1);
+ forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
+ forwTraySide2->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
+ traySide3, medAl);
+
+ forwTraySide3->SetVisibility(kTRUE);
+ forwTraySide3->SetLineColor(6); // Purple
+ forwTraySide3->SetLineWidth(1);
+ forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
+ forwTraySide3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
+ trayHorWing, medAl);
+
+ forwTrayHWing->SetVisibility(kTRUE);
+ forwTrayHWing->SetLineColor(6); // Purple
+ forwTrayHWing->SetLineWidth(1);
+ forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
+ forwTrayHWing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
+ trayVertWing, medAl);
+
+ forwTrayVWing->SetVisibility(kTRUE);
+ forwTrayVWing->SetLineColor(6); // Purple
+ forwTrayVWing->SetLineWidth(1);
+ forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
+ forwTrayVWing->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ yloc = kForwardTrayThick/2;
+ zloc = zlen;
+ tray->AddNode(forwTrayBase, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ xloc = kForwardTrayBaseHalfWide;
+ tray->AddNode(forwTraySide1, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ xloc = -xloc + kForwardTrayThick;
+ tray->AddNode(forwTraySide1, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ tray->AddNode(forwTraySide2, 1, 0);
+ zloc = kForwardTraySideLength;
+ tray->AddNode(forwTraySide2, 2,
+ new TGeoCombiTrans(0, 0, zloc,
+ new TGeoRotation("",90,-180,-90)));
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
+ tray->AddNode(forwTraySide3, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ xloc = -xloc + kForwardTrayThick;
+ tray->AddNode(forwTraySide3, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
+ - kForwardTrayHorWingWide/2;
+ yloc = traySide3->GetY(2) + kForwardTrayThick/2;
+ zloc = kForwardTraySideLength - trayHorWing->GetDZ();
+ tray->AddNode(forwTrayHWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayHWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
+ - kForwardTrayVertWingWide/2;
+ yloc = traySide3->GetY(2) + trayVertWing->GetDY();
+ zloc = traySide3->GetX(3) + kForwardTrayThick/2;
+ tray->AddNode(forwTrayVWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayVWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
+//
+// Creates the forward cover of the SDD and SSD cable trays on Side A
+// (0872/G/D/02)
+//
+// Input:
+// coverLen: the total length of the cover
+//
+// Output:
+//
+// Return: a TGeoCompositeShape for the cover
+//
+// Created: 03 Jan 2010 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 A-Side Cable Tray Forward Cover
+ // (0872/G/D/02)
+ const Double_t kForwardCoverWide = 130.00 *fgkmm;
+ const Double_t kForwardCoverSideWide = 10.00 *fgkmm;
+ const Double_t kForwardCoverHoleLen = 160.00 *fgkmm;
+ const Double_t kForwardCoverHoleWide = 90.00 *fgkmm;
+ const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm;
+ const Double_t kForwardCoverTotalThick = 5.00 *fgkmm;
+ const Double_t kForwardCoverSideThick = 3.00 *fgkmm;
+ const Double_t kForwardCoverInternThick = 2.00 *fgkmm;
+
+ const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm;
+
+
+ // Local variables
+ Double_t xprof[16], yprof[16];
+ Double_t yloc, zloc;
+
+
+ // The main shape: a Xtru
+ TGeoXtru *forwCoverMain = new TGeoXtru(2);
+ forwCoverMain->SetName("ITSsuppForwCoverMain");
+
+ xprof[0] = kForwardCoverWide/2;
+ yprof[0] = kForwardCoverTotalThick;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] - kForwardCoverSideThick;
+ xprof[2] = xprof[1] - kForwardCoverSideWide;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ // And now the actual Xtru
+ forwCoverMain->DefinePolygon(8, xprof, yprof);
+ forwCoverMain->DefineSection(0, 0);
+ forwCoverMain->DefineSection(1, coverLen);
+
+ // The hole: another Xtru (rounded corners approximated with segments)
+ TGeoXtru *forwCoverHole = new TGeoXtru(2);
+ forwCoverHole->SetName("ITSsuppForwCoverHole");
+
+ CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
+ kForwardCoverHoleR10 , xprof, yprof);
+
+ // And now the actual Xtru
+ forwCoverHole->DefinePolygon(16, xprof, yprof);
+ forwCoverHole->DefineSection(0, 0);
+ forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
+
+ // Now the proper rototranslation matrices for the two holes
+ yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
+ zloc = kForwardCoverHoleZTrans;
+ TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ mf1->SetName("mf1");
+ mf1->RegisterYourself();
+
+ zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
+ TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ mf2->SetName("mf2");
+ mf2->RegisterYourself();
+
+ // Finally the actual cover shape
+ TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
+ "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
+
+ return cover;
+}
+
+//______________________________________________________________________
+TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
+//
+// Creates the external cover of the SDD and SSD cable trays on Side A
+// (0872/G/D/04)
+//
+// Input:
+// coverLen: the total length of the cover
+//
+// Output:
+//
+// Return: a TGeoCompositeShape for the cover
+//
+// Created: 03 Jan 2010 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 A-Side Cable Tray External Cover
+ // (0872/G/D/04)
+ const Double_t kExternalCoverWide = 130.00 *fgkmm;
+ const Double_t kExternalCoverSideWide = 10.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm;
+ const Double_t kExternalCoverHoleWide = 90.00 *fgkmm;
+ const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm;
+ const Double_t kExternalCoverTotalThick = 5.00 *fgkmm;
+ const Double_t kExternalCoverSideThick = 3.00 *fgkmm;
+ const Double_t kExternalCoverInternThick = 2.00 *fgkmm;
+
+ const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm;
+ const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm;
+
+
+ // Local variables
+ Double_t xprof[16], yprof[16];
+ Double_t yloc, zloc;
+
+
+ // The main shape: a Xtru
+ TGeoXtru *externCoverMain = new TGeoXtru(2);
+ externCoverMain->SetName("ITSsuppExternCoverMain");
+
+ xprof[0] = kExternalCoverWide/2;
+ yprof[0] = kExternalCoverTotalThick;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] - kExternalCoverSideThick;
+ xprof[2] = xprof[1] - kExternalCoverSideWide;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ // And now the actual Xtru
+ externCoverMain->DefinePolygon(8, xprof, yprof);
+ externCoverMain->DefineSection(0, 0);
+ externCoverMain->DefineSection(1, coverLen);
+
+ // The first hole: a Xtru (rounded corners approximated with segments)
+ Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
+
+ TGeoXtru *extCoverHole1 = new TGeoXtru(2);
+ extCoverHole1->SetName("ITSsuppExtCoverHole1");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole1->DefinePolygon(16, xprof, yprof);
+ extCoverHole1->DefineSection(0, 0);
+ extCoverHole1->DefineSection(1, holethick);
+
+ // The second (and third) hole: another Xtru
+ TGeoXtru *extCoverHole2 = new TGeoXtru(2);
+ extCoverHole2->SetName("ITSsuppExtCoverHole2");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole2->DefinePolygon(16, xprof, yprof);
+ extCoverHole2->DefineSection(0, 0);
+ extCoverHole2->DefineSection(1, holethick);
+
+ // The fourth hole: another Xtru
+ TGeoXtru *extCoverHole3 = new TGeoXtru(2);
+ extCoverHole3->SetName("ITSsuppExtCoverHole3");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole3->DefinePolygon(16, xprof, yprof);
+ extCoverHole3->DefineSection(0, 0);
+ extCoverHole3->DefineSection(1, holethick);
+
+ // The fifth and last hole: another Xtru
+ TGeoXtru *extCoverHole4 = new TGeoXtru(2);
+ extCoverHole4->SetName("ITSsuppExtCoverHole4");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole4->DefinePolygon(16, xprof, yprof);
+ extCoverHole4->DefineSection(0, 0);
+ extCoverHole4->DefineSection(1, holethick);
+
+ // Now the proper rototranslation matrices for the holes
+ yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
+ zloc = kExternalCoverHole1ZTrans;
+ TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me1->SetName("me1");
+ me1->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me2->SetName("me2");
+ me2->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me3->SetName("me3");
+ me3->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me4->SetName("me4");
+ me4->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me5->SetName("me5");
+ me5->RegisterYourself();
+
+ // Finally the actual cover shape
+ TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
+ "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
+
+ return cover;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
+ const Double_t length, const Double_t r10,
+ Double_t *x, Double_t *y){
+//
+// Creates the proper sequence of X and Y coordinates to determine
+// the base XTru polygon for the holes in the SDD and SSD tray covers
+// (here the rounded corners are approximated with segments)
+//
+// Input:
+// wide : the hole wide
+// length : the hole length
+// r10 : the radius of the rounded corners
+//
+// Output:
+// x, y : coordinate vectors [16]
+//
+// Created: 03 Jan 2010 Mario Sitta
+//
+// Caller must guarantee that x and y have the correct dimensions
+// (but being this a private method it's easy to tell)
+//
+
+ x[0] = wide/2 - r10;
+ y[0] = length;
+ x[1] = x[0] + r10*SinD(30);
+ y[1] = y[0] - r10*(1 - CosD(30));
+ x[2] = x[0] + r10*SinD(60);
+ y[2] = y[0] - r10*(1 - CosD(60));
+ x[3] = x[0] + r10;
+ y[3] = y[0] - r10;
+ x[4] = x[3];
+ y[4] = r10;
+ x[5] = x[4] - r10*(1 - CosD(30));
+ y[5] = y[4] - r10*SinD(30);
+ x[6] = x[4] - r10*(1 - CosD(60));
+ y[6] = y[4] - r10*SinD(60);
+ x[7] = x[4] - r10;
+ y[7] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 8; jp++) {
+ x[8+jp] = -x[7-jp];
+ y[8+jp] = y[7-jp];
+ }
+
+ return;
+}
+
+//______________________________________________________________________
+TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
+ const Double_t trayLen,
+ const Double_t trayHi){
+//
+// Creates parts of the SDD and SSD Trays on Side A which are identical
+// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
+//
+// Input:
+// trayLen : the length of the tray part
+// trayHi : the height of the tray part
+//
+// Output:
+//
+// Return: a TGeoXtru
+//
+// Created: 26 Feb 2010 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 A-Side Cable Trays
+ // (parts of 0872/G/C)
+ const Double_t kTrayWidth = 130.00 *fgkmm;
+ const Double_t kTrayWingWidth = 10.00 *fgkmm;
+ const Double_t kTrayHeightToBend = 20.00 *fgkmm;
+ const Double_t kTrayThick = 2.00 *fgkmm;
+
+ const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
+
+ const Int_t kTrayNpoints = 16;
+
+ // Local variables
+ Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
+
+
+ // The tray shape: a Xtru
+ TGeoXtru *trayPart = new TGeoXtru(2);
+
+ xprof[2] = kTrayWidth/2 - kTrayThick;
+ yprof[2] = trayHi - kTrayThick;
+ xprof[3] = kTrayWidth/2 - kTrayWingWidth;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = trayHi;
+ xprof[5] = kTrayWidth/2;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = kTrayHeightToBend;
+ xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
+ yprof[7] = 0;
+
+ InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
+ -kTrayThick, xprof[1], yprof[1]);
+
+ xprof[8] = -xprof[7];
+ yprof[8] = yprof[7];
+
+ InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
+ -kTrayThick, xprof[0], yprof[0]);
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 8; jp++) {
+ xprof[8+jp] = -xprof[7-jp];
+ yprof[8+jp] = yprof[7-jp];
+ }
+
+ // And now the actual Xtru
+ trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
+ trayPart->DefineSection(0, 0);
+ trayPart->DefineSection(1, trayLen);
+
+
+ return trayPart;
+}
+
+//______________________________________________________________________
+TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
+ const char *trayName,
+ const TGeoManager *mgr){
+
+//
+// Creates the SDD and SSD Trays on Side C which are supposedly identical
+//
+// Input:
+// trayName : the assembly name
+//
+// Output:
+//
+// Return: a TGeoVolumeAssembly
+//
+// Created: 16 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ const Double_t kSideCHalfThick = 0.100 *fgkcm;
+ const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad();
+
+ const Double_t kSideCLength1 = 172.800 *fgkcm;
+ const Double_t kSideCLength2 = 189.300 *fgkcm;
+ const Double_t kSideCHalfWide = 6.350 *fgkcm;
+ const Double_t kSideCHeight1 = 11.800 *fgkcm;
+ const Double_t kSideCHeight2 = 4.300 *fgkcm;
+ const Double_t kSideCSideLength1 = 10.800 *fgkcm;
+ const Double_t kSideCSideLength2 = 63.800 *fgkcm;
+ const Double_t kSideCSideHeight = 8.800 *fgkcm;
+ const Int_t kNPointsLowerFace = 6;
+ const Int_t kNPointsLateralFace = 9;
+
+ const Double_t kSideCWingAHalfLen = 5.000 *fgkcm;
+ const Double_t kSideCWingBHalfLen = 30.500 *fgkcm;
+ const Double_t kSideCWingCHalfLen = 2.000 *fgkcm;
+ const Double_t kSideCWingDHalfLen = 48.500 *fgkcm;
+ const Double_t kSideCWingEHalfLen = 83.000 *fgkcm;
+ const Double_t kSideCWingsHalfWide = 0.450 *fgkcm;
+
+ const Int_t kNPointsCoverFace = 12;
+
+ const Double_t kPlateHalfLen = 6.000 *fgkcm;
+ const Double_t kPlateThick = 0.600 *fgkcm;
+ const Double_t kPlateHeight = 4.200 *fgkcm;
+ const Int_t kNPointsPlate = 6;
+
+ const Double_t kBarCoolRmax = 0.4 *fgkcm;
+ const Int_t kNumBarCool = 2;
+ const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
+ const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 };
+
+
+ // Local variables
+ Double_t xprof[12], yprof[12];
+ Double_t xloc, yloc, zloc, delta, alpharot;
+
+ // The single C-Side Cable tray as an assembly
+ TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);
+
+ // First create all needed shapes
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCLowerFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kSideCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ 2*kSideCHalfThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = 2*kSideCHalfThick;
+
+ sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
+ sideCLowerFace->DefineSection(0,-kSideCHalfWide);
+ sideCLowerFace->DefineSection(1, kSideCHalfWide);
+
+ // The Cable Tray lateral face: a Xtru
+ TGeoXtru *sideCLateralFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kSideCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideCHeight2, xprof[4], yprof[4]);
+ xprof[5] = kSideCSideLength1 + kSideCSideLength2;
+ yprof[5] = kSideCHeight2;
+ xprof[6] = xprof[5];
+ yprof[6] = kSideCSideHeight;
+ xprof[7] = kSideCSideLength1;
+ yprof[7] = kSideCHeight1;
+ xprof[8] = 0;
+ yprof[8] = yprof[7];
+
+ sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
+ sideCLateralFace->DefineSection(0,-kSideCHalfThick);
+ sideCLateralFace->DefineSection(1, kSideCHalfThick);
+
+ // The lateral wings: four BBox's
+ TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these
+ kSideCWingCHalfLen, // X,Y avoid
+ kSideCWingsHalfWide);//rotations
+
+ TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ // The connecting lower plate: a Xtru
+ TGeoXtru *sideCLowerPlate = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kPlateHalfLen;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPlateThick, xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = kPlateThick;
+
+ sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
+ Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
+ sideCLowerPlate->DefineSection(0,-zwide);
+ sideCLowerPlate->DefineSection(1, zwide);
+
+ // The connecting side plate: a Xtru
+ TGeoXtru *sideCLateralPlate = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kPlateHalfLen;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
+ xprof[5] = 0.;
+ yprof[5] = kPlateHeight;
+
+ sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
+ sideCLateralPlate->DefineSection(0,-kPlateThick/2);
+ sideCLateralPlate->DefineSection(1, kPlateThick/2);
+
+ // The bar fixing the cooling tubes: a Tube
+ TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);
+
+ // The Cable Tray cover: a (complex) Xtru
+ TGeoXtru *sideCCoverFace = new TGeoXtru(2);
+
+ xprof[ 0] = sideCLateralFace->GetX(8);
+ yprof[ 0] = sideCLateralFace->GetY(8);
+ xprof[ 1] = sideCLateralFace->GetX(7);
+ yprof[ 1] = sideCLateralFace->GetY(7);
+ xprof[ 2] = sideCLateralFace->GetX(6);
+ yprof[ 2] = sideCLateralFace->GetY(6);
+ xprof[ 3] = sideCLateralFace->GetX(5);
+ yprof[ 3] = sideCLateralFace->GetY(5);
+ xprof[ 4] = sideCLateralFace->GetX(4);
+ yprof[ 4] = sideCLateralFace->GetY(4);
+
+ xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
+ delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
+ xprof[ 5] = xprof[4]
+ + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
+ yprof[ 5] = yprof[4]
+ + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);
+
+ xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
+ yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
+ 2*kSideCHalfThick, xprof[7], yprof[7]);
+ InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
+ 2*kSideCHalfThick, xprof[8], yprof[8]);
+ xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
+ yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
+ xprof[10] = xprof[1];
+ yprof[10] = yprof[1] + 2*kSideCHalfThick;
+ xprof[11] = xprof[0];
+ yprof[11] = yprof[0] + 2*kSideCHalfThick;
+
+ sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
+ sideCCoverFace->DefineSection(0,-zloc);
+ sideCCoverFace->DefineSection(1, zloc);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+
+ TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower",
+ sideCLowerFace, medAl);
+
+ traySideCLowerFace->SetVisibility(kTRUE);
+ traySideCLowerFace->SetLineColor(6); // Purple
+ traySideCLowerFace->SetLineWidth(1);
+ traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
+ traySideCLowerFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral",
+ sideCLateralFace, medAl);
+
+ traySideCLateralFace->SetVisibility(kTRUE);
+ traySideCLateralFace->SetLineColor(6); // Purple
+ traySideCLateralFace->SetLineWidth(1);
+ traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
+ traySideCLateralFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingA =
+ new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl);
+
+ traySideCLateralWingA->SetVisibility(kTRUE);
+ traySideCLateralWingA->SetLineColor(6); // Purple
+ traySideCLateralWingA->SetLineWidth(1);
+ traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
+ traySideCLateralWingA->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingB =
+ new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl);
+
+ traySideCLateralWingB->SetVisibility(kTRUE);
+ traySideCLateralWingB->SetLineColor(6); // Purple
+ traySideCLateralWingB->SetLineWidth(1);
+ traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
+ traySideCLateralWingB->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingC =
+ new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl);
+
+ traySideCLateralWingC->SetVisibility(kTRUE);
+ traySideCLateralWingC->SetLineColor(6); // Purple
+ traySideCLateralWingC->SetLineWidth(1);
+ traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
+ traySideCLateralWingC->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingD =
+ new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl);
+
+ traySideCLateralWingD->SetVisibility(kTRUE);
+ traySideCLateralWingD->SetLineColor(6); // Purple
+ traySideCLateralWingD->SetLineWidth(1);
+ traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
+ traySideCLateralWingD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingE =
+ new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl);
+
+ traySideCLateralWingE->SetVisibility(kTRUE);
+ traySideCLateralWingE->SetLineColor(6); // Purple
+ traySideCLateralWingE->SetLineWidth(1);
+ traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
+ traySideCLateralWingE->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowerPlate =
+ new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl);
+
+ traySideCLowerPlate->SetVisibility(kTRUE);
+ traySideCLowerPlate->SetLineColor(6); // Purple
+ traySideCLowerPlate->SetLineWidth(1);
+ traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
+ traySideCLowerPlate->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralPlate =
+ new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl);
+
+ traySideCLateralPlate->SetVisibility(kTRUE);
+ traySideCLateralPlate->SetLineColor(6); // Purple
+ traySideCLateralPlate->SetLineWidth(1);
+ traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
+ traySideCLateralPlate->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoverFace =
+ new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl);
+
+ traySideCCoverFace->SetVisibility(kTRUE);
+ traySideCCoverFace->SetLineColor(6); // Purple
+ traySideCCoverFace->SetLineWidth(1);
+ traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
+ traySideCCoverFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
+ coolBar, medAl);
+
+ coolingTubeBar->SetVisibility(kTRUE);
+ coolingTubeBar->SetLineColor(6); // Purple
+ coolingTubeBar->SetLineWidth(1);
+ coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
+ coolingTubeBar->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ cableTrayC->AddNode(traySideCLowerFace,1,0);
+
+ zloc = kSideCHalfWide + kSideCHalfThick;
+ cableTrayC->AddNode(traySideCLateralFace,1,
+ new TGeoTranslation(0., 0., zloc) );
+ cableTrayC->AddNode(traySideCLateralFace,2,
+ new TGeoTranslation(0., 0.,-zloc) );
+
+ xloc = kSideCWingAHalfLen;
+ yloc = kSideCHeight1 - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingA,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingA,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ xloc = kSideCSideLength1 + kSideCSideLength2/2;
+ yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
+ kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
+ xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
+ TMath::RadToDeg();
+ cableTrayC->AddNode(traySideCLateralWingB,1,
+ new TGeoCombiTrans(xloc, yloc, zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+ cableTrayC->AddNode(traySideCLateralWingB,2,
+ new TGeoCombiTrans(xloc, yloc,-zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+
+ xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
+ yloc = kSideCSideHeight - kSideCWingCHalfLen;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingC,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingC,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
+ yloc = kSideCHeight2 - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingD,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingD,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
+ xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
+ yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
+ kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ alpharot = kSideCFoldAngle*TMath::RadToDeg();
+ cableTrayC->AddNode(traySideCLateralWingE,1,
+ new TGeoCombiTrans(xloc, yloc, zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+ cableTrayC->AddNode(traySideCLateralWingE,2,
+ new TGeoCombiTrans(xloc, yloc,-zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+
+ xloc = kSideCLength1 - kPlateHalfLen;
+ yloc = -kPlateThick -0.0025; // Avoid small overlap
+ cableTrayC->AddNode(traySideCLowerPlate,1,
+ new TGeoTranslation(xloc, yloc, 0.) );
+
+ xloc = kSideCLength1 - kPlateHalfLen;
+ yloc = -kPlateThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
+ cableTrayC->AddNode(traySideCLateralPlate,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralPlate,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ for (Int_t jc = 0; jc <kNumBarCool; jc++) {
+ xloc = kXShiftBarCool[jc];
+ yloc = kYShiftBarCool[jc];
+ cableTrayC->AddNode(coolingTubeBar,jc+1,
+ new TGeoTranslation(xloc, yloc, 0.) );
+ }
+
+ cableTrayC->AddNode(traySideCCoverFace,1,0);
+
+
+ // Finally return what we made up
+
+ return cableTrayC;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the elements suspending the ITS to the TPC and other fixed
+// elements used to hook the rails (0872/C and its daughters)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Return:
+//
+// Created: 28 Oct 2010 Mario Sitta
+// Updated: 18 Feb 2011 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the half ring C2/C3 (0872/C/04)
+ const Double_t kRingCZPos = 733.000*fgkmm;
+ const Double_t kRingCZToTPC = 5.500*fgkmm;
+
+ const Double_t kRingCThick = 12.000*fgkmm;
+ const Double_t kRingCRmin = 565.000*fgkmm;
+ const Double_t kRingCRmax = 592.000*fgkmm;
+ const Double_t kRingCHeight = 560.000*fgkmm;
+ const Double_t kRingCXToInsert = 515.000*fgkmm;
+ const Double_t kRingCYToInsert = 113.000*fgkmm;
+
+ const Int_t kNumberOfRingPoints = 23; // N.points to approximate arc
+
+ // Dimensions of the forward upper hook (0872/C/09)
+ const Double_t kForwUpHookThick = 20.000*fgkmm;
+ const Double_t kForwUpHookRext = 590.000*fgkmm;
+ const Double_t kForwUpHookRint = 20.000*fgkmm;
+ const Double_t kForwUpHookHiTot = 89.000*fgkmm;
+ const Double_t kForwUpHookHiInt = 59.000*fgkmm;
+ const Double_t kForwUpHookWide = 96.000*fgkmm;
+ const Double_t kForwUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwUpHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kForwUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kForwUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleY = 8.000*fgkmm;
+ const Double_t kForwUpHookHollowHi = 35.000*fgkmm;
+ const Double_t kForwUpHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwUpHookPts = 11;
+ const Int_t kNumbOfForwUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/08)
+ const Double_t kForwLwHookThick = 20.000*fgkmm;
+ const Double_t kForwLwHookRext = 590.000*fgkmm;
+ const Double_t kForwLwHookRint = 20.000*fgkmm;
+ const Double_t kForwLwHookHiTot = 88.500*fgkmm;
+ const Double_t kForwLwHookWide = 96.000*fgkmm;
+ const Double_t kForwLwHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwLwHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwLwHookYToHollow = 3.500*fgkmm;
+ const Double_t kForwLwHookHoleR = 7.500*fgkmm;
+ const Double_t kForwLwHookHoleIntHi = 35.000*fgkmm;
+ const Double_t kForwLwHookHoleYPos = 13.500*fgkmm;
+ const Double_t kForwLwHookHollowHi = 62.000*fgkmm;
+ const Double_t kForwLwHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwLwHookPts = 11;
+ const Int_t kNumbOfForwLwHookHolePts= 7;
+
+ // Dimensions of the rear upper hook (0872/C/10)
+ const Double_t kRearUpHookThick = 15.000*fgkmm;
+ const Double_t kRearUpHookRext = 590.000*fgkmm;
+ const Double_t kRearUpHookRint = 20.000*fgkmm;
+ const Double_t kRearUpHookHiTot = 53.500*fgkmm;
+ const Double_t kRearUpHookHiInt = 23.500*fgkmm;
+ const Double_t kRearUpHookWide = 96.000*fgkmm;
+ const Double_t kRearUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kRearUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleY = 8.000*fgkmm;
+
+ const Int_t kNumberOfRearUpHookPts = 10;
+ const Int_t kNumbOfRearUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/11)
+ const Double_t kRearLwHookThick = 20.000*fgkmm;
+ const Double_t kRearLwHookRext = 590.000*fgkmm;
+ const Double_t kRearLwHookHiTot = 30.000*fgkmm;
+ const Double_t kRearLwHookWide = 96.000*fgkmm;
+
+ const Int_t kNumberOfRearLwHookPts = 3;
+
+ // Dimensions of the rear lower brackets (0872/C/16)
+ const Double_t kRearLwBracketThick = 15.000*fgkmm;
+ const Double_t kRearLwBracketHi1 = 42.000*fgkmm;
+ const Double_t kRearLwBracketHi2 = 12.000*fgkmm;
+ const Double_t kRearLwBracketWide1 = 34.000*fgkmm;
+ const Double_t kRearLwBracketWide2 = 10.000*fgkmm;
+// const Double_t kRearLwBracketR5 = 5.000*fgkmm
+
+ // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
+ const Double_t kForwWebSStirrDep = 20.000*fgkmm;
+ const Double_t kForwWebSStirrLen1 = 15.000*fgkmm;
+ const Double_t kForwWebSStirrLen2 = 55.000*fgkmm;
+ const Double_t kForwWebSStirrLen3 = 10.000*fgkmm;
+ const Double_t kForwWebSStirrWide1 = 45.000*fgkmm;
+ const Double_t kForwWebSStirrWide2 = 38.000*fgkmm;
+ const Double_t kForwWebSStirrWide3 = 23.000*fgkmm;
+ const Double_t kForwWebTStirrThick = 5.000*fgkmm;
+ const Double_t kForwWebTStirrWide1 = 30.000*fgkmm;
+ const Double_t kForwWebTStirrWide2 = 10.000*fgkmm;
+ const Double_t kForwWebTStirrTotLen3= 58.500*fgkmm;
+ const Double_t kForwWebTStirrTotLen4= 36.000*fgkmm;
+ const Double_t kForwWebTStirrLen1 = 10.000*fgkmm;
+
+ // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
+ const Double_t kFRWebClampThick = 10.000*fgkmm;
+ const Double_t kFRWebClampExtWide = 30.000*fgkmm;
+ const Double_t kFRWebClampIntWide = 18.000*fgkmm;
+ const Double_t kFRWebClampExtHi = 22.000*fgkmm;
+ const Double_t kFRWebClampIntHi = 17.000*fgkmm;
+
+ // Dimensions of the webcam itself
+ const Double_t kWebcamLength = 35.000*fgkmm;//ESTIMATED!!!
+
+ // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
+ const Double_t kRearUpWebStirrWide = 76.000*fgkmm;
+ const Double_t kRearUpWebStirrDep = 15.000*fgkmm;
+ const Double_t kRearUpWebStirrThick = 5.000*fgkmm;
+ const Double_t kRearUpWebStirrH1 = 27.000*fgkmm;
+ const Double_t kRearUpWebStirrH2 = 32.000*fgkmm;
+ const Double_t kRearUpWebBarLen = 130.000*fgkmm;
+ const Double_t kRearUpWebBarHi = 20.000*fgkmm;
+ const Double_t kRearUpWebBarThick = 5.000*fgkmm;
+
+ // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
+ const Double_t kUpperSlideTotHeight = 93.500*fgkmm;
+ const Double_t kUpperSlideBlockHi = 62.500*fgkmm;
+ const Double_t kUpperSlideWidth = 36.000*fgkmm;
+ const Double_t kUpperSlideTotDepth = 51.000*fgkmm;
+ const Double_t kUpperSlideIntDepth = 36.000*fgkmm;
+ const Double_t kUpperSlideStubHi = 15.000*fgkmm;
+ const Double_t kUpperSlideStubDep = 8.000*fgkmm;
+ const Double_t kUpperSlideWheelHi = 18.500*fgkmm;
+ const Double_t kUpperSlideHoleRout = 11.000*fgkmm;
+ const Double_t kUpperSlideHoleRint1 = 9.000*fgkmm;
+ const Double_t kUpperSlideHoleRint2 = 11.500*fgkmm;
+ const Double_t kUpperSlideHoleH1 = 7.000*fgkmm;
+ const Double_t kUpperSlideHoleH2 = 46.000*fgkmm;
+ const Double_t kUpperSlideHoleH3 = 1.100*fgkmm;
+ const Double_t kUpperSlideHoleXPos = 20.000*fgkmm;
+ const Double_t kUpperSlidePinRmin = 4.000*fgkmm;
+ const Double_t kUpperSlidePinRmax = 6.000*fgkmm;
+ const Double_t kUpperSlidePinH1 = 7.000*fgkmm;
+ const Double_t kUpperSlidePinH2 = 46.000*fgkmm;
+ const Double_t kUpperSlidePinH3 = 25.500*fgkmm;
+
+ // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
+ const Double_t kLowerSlideTotHeight = 80.000*fgkmm;
+ const Double_t kLowerSlideBlockHi = 28.000*fgkmm;
+ const Double_t kLowerSlideWidth = 36.000*fgkmm;
+ const Double_t kLowerSlideTotDepth = 60.000*fgkmm;
+ const Double_t kLowerSlideHoleRout = 9.500*fgkmm;
+ const Double_t kLowerSlideHoleRint = 4.700*fgkmm;
+ const Double_t kLowerSlideHoleH1 = 12.000*fgkmm;
+ const Double_t kLowerSlideNoseBase = 40.000*fgkmm;
+ const Double_t kLowerSlideNoseBasHi = 6.000*fgkmm;//Computed
+ const Double_t kLowerSlideNoseUpWid = 25.000*fgkmm;
+ const Double_t kLowerSlideNoseDepth = 10.000*fgkmm;
+ const Double_t kLowerSlidePinRmin = 3.000*fgkmm;
+ const Double_t kLowerSlidePinRmax = 4.000*fgkmm;
+ const Double_t kLowerSlidePinH1 = 12.000*fgkmm;
+ const Double_t kLowerSlidePinH2 = 10.000*fgkmm;
+
+ // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
+ const Double_t kStirrCXPos = 759.000*fgkmm;
+ const Double_t kStirrCZPos = 1867.000*fgkmm;
+
+ const Double_t kStirrC12Thick = 15.000*fgkmm;
+ const Double_t kStirrC12TotLen = 314.000*fgkmm;
+ const Double_t kStirrC12BodyHalfHi = 95.000*fgkmm;
+ const Double_t kStirrC12BodyLen = 153.000*fgkmm;
+ const Double_t kStirrC12HeadLen = 50.000*fgkmm;
+ const Double_t kStirrC12HeadHalfHi = 165.000*fgkmm;
+ const Double_t kStirrC12HeadIntHi = 114.000*fgkmm;
+ const Double_t kStirrC12HeadIntLen = 45.000*fgkmm;
+ const Double_t kStirrC12TailLen = 14.000*fgkmm;
+ const Double_t kStirrC12R100 = 100.000*fgkmm;
+ const Double_t kStirrC12R50 = 50.000*fgkmm;
+ const Double_t kStirrC12R10 = 10.000*fgkmm;
+ const Double_t kStirrC12HeadAng = 40.000; // Degree
+
+ const Int_t kNumberOfStirrCPoints = 23;
+
+ // Dimensions and positions of the C5 rail stirrups (0872/C/05)
+ const Double_t kStirrC5BodyLen = 155.000*fgkmm;
+
+
+ // Local variables
+ Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
+ Double_t xpos, ypos, zpos, alpha;
+ Double_t xdummy, ydummy;
+
+
+ // First create all needed shapes
+
+ // The Supporting Ring (0872/C/04): a really complex Xtru
+ // to approximate the arc with a polyline
+ TGeoXtru *ringC2C3 = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The external arc
+ xprof[j] = kRingCRmax*SinD(90*j/10);
+ yprof[j] = kRingCRmax*CosD(90*j/10);
+ }
+
+ xprof[11] = kRingCRmin;
+ yprof[11] = yprof[10];
+
+ alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
+ xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
+ yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
+ xprof[13] = kRingCRmin*TMath::Cos(alpha);
+ yprof[13] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[14] = kRingCXToInsert;
+ yprof[14] = yprof[13];
+
+ alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
+ xprof[15] = kRingCRmin*TMath::Cos(alpha);
+ yprof[15] = kRingCRmin*TMath::Sin(alpha);
+
+ for (Int_t j=7; j>1; j--) { // The internal arc
+ xprof[23-j] = kRingCRmin*SinD(90*j/10);
+ yprof[23-j] = kRingCRmin*CosD(90*j/10);
+ }
+
+ alpha = TMath::ASin(kRingCHeight/kRingCRmin); // The angle till the notch
+ xprof[22] = kRingCRmin*TMath::Cos(alpha);
+ yprof[22] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[23] = xprof[0];
+ yprof[23] = yprof[22];
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 22; jp++) {
+ xprof[24+jp] = -xprof[23-1-jp];
+ yprof[24+jp] = yprof[23-1-jp];
+ }
+
+ // wow! now the actual Xtru
+ ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
+ ringC2C3->DefineSection(0, 0);
+ ringC2C3->DefineSection(1, kRingCThick);
+
+ // The Forward Upper Hook (0872/C/09): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
+ forwUpHookMainBody->SetName("ITSforwUpHookMainBody");
+
+ xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
+ yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
+ xprof[ 1] = kForwUpHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwUpHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
+ yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
+ forwUpHookMainBody->DefineSection(0, 0);
+ forwUpHookMainBody->DefineSection(1, kForwUpHookThick);
+
+ // The hole
+ TGeoXtru *forwUpHookHole = new TGeoXtru(2);
+ forwUpHookHole->SetName("ITSforwUpHookHole");
+
+ xprof[0] = kForwUpHookHoleBase/2;
+ yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
+ xprof[1] = kForwUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
+ xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kForwUpHookHoleR5;
+ yprof[4] = yprof[0] + kForwUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
+ forwUpHookHole->DefineSection(0, -0.1);
+ forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
+ 0.55*kForwUpHookHollowHi,
+ 0.55*kForwUpHookHollowWide);
+ forwUpHookHollow->SetName("ITSforwUpHookHollow");
+
+ TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
+ forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
+ forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
+ forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
+ forwUpHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");
+
+ // The Forward Lower Hook (0872/C/08): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
+ forwLwHookMainBody->SetName("ITSforwLwHookMainBody");
+
+ xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
+ yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
+ xprof[ 1] = kForwLwHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
+ - kForwLwHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwLwHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
+ yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
+ forwLwHookMainBody->DefineSection(0, 0);
+ forwLwHookMainBody->DefineSection(1, kForwLwHookThick);
+
+ // The hole
+ TGeoXtru *forwLwHookHole = new TGeoXtru(2);
+ forwLwHookHole->SetName("ITSforwLwHookHole");
+
+ xprof[0] = 0;
+ yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
+ - kForwLwHookHoleR;
+ for (Int_t j=1; j<3; j++) {
+ xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
+ yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
+ }
+ xprof[3] = xprof[0] + kForwLwHookHoleR;
+ yprof[3] = yprof[0] + kForwLwHookHoleR;
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
+ for (Int_t j=1; j<3; j++) {
+ xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
+ yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
+ }
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[4] + kForwLwHookHoleR;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
+ xprof[8+jp] = -xprof[6-jp];
+ yprof[8+jp] = yprof[6-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
+ forwLwHookHole->DefineSection(0, -0.1);
+ forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
+ 0.55*kForwLwHookHollowHi,
+ 0.55*kForwLwHookHollowWide);
+ forwLwHookHollow->SetName("ITSforwLwHookHollow");
+
+ TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
+ forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
+ forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
+ forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
+ forwLwHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");
+
+ // The Rear Upper Hook (0872/C/10): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // and another Xtru for the hole
+ // The main body
+ TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
+ rearUpHookMainBody->SetName("ITSrearUpHookMainBody");
+
+ xprof[0] = kRearUpHookHalfBase;
+ yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
+ yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 7] = kRearUpHookWide/2;
+ yprof[ 7] = yprof[5];
+ xprof[ 8] = xprof[7];
+ alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
+ yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
+ xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
+ yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
+ xprof[10] = 0;
+ yprof[10] = kRearUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
+ xprof[11+jp] = -xprof[9-jp];
+ yprof[11+jp] = yprof[9-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
+ rearUpHookMainBody->DefineSection(0, 0);
+ rearUpHookMainBody->DefineSection(1, kRearUpHookThick);
+
+ // The hole
+ TGeoXtru *rearUpHookHole = new TGeoXtru(2);
+ rearUpHookHole->SetName("ITSrearUpHookHole");
+
+ xprof[0] = kRearUpHookHoleBase/2;
+ yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
+ xprof[1] = kRearUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
+ xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kRearUpHookHoleR5;
+ yprof[4] = yprof[0] + kRearUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
+ rearUpHookHole->DefineSection(0, -0.1);
+ rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");
+
+ // The Rear Lower Hook (0872/C/11): a Xtru
+ TGeoXtru *rearLwHookShape = new TGeoXtru(2);
+ rearLwHookShape->SetName("ITSrearLwHookShape");
+
+ xprof[0] = kRearLwHookWide/2;
+ yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
+ xprof[1] = xprof[0];
+ alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
+ yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
+ xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
+ yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
+ xprof[3] = 0;
+ yprof[3] = kRearLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
+ xprof[4+jp] = -xprof[2-jp];
+ yprof[4+jp] = yprof[2-jp];
+ }
+
+ // Now the actual Xtru
+ rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
+ rearLwHookShape->DefineSection(0, 0);
+ rearLwHookShape->DefineSection(1, kRearLwHookThick);
+
+ // The Rear Lower Bracket (0872/C/16): a Xtru
+ TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
+ rearLwBrackShape->SetName("ITSrearLwBrackShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearLwBracketHi2;
+ xprof[3] = xprof[2] - kRearLwBracketWide1;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearLwBracketHi1;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ rearLwBrackShape->DefinePolygon(6, xprof, yprof);
+ rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
+ rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);
+
+ // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
+ TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kForwWebSStirrLen1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kForwWebSStirrWide1;
+ xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwWebSStirrWide3;
+ xprof[5] = xprof[4] - kForwWebSStirrLen3;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[0] + kForwWebSStirrWide2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
+ forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
+ forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);
+
+ // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
+ TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);
+
+ xprof[0] = -kForwWebTStirrWide2/2;
+ yprof[0] = 0;
+ xprof[1] = -kForwWebTStirrWide1/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kForwWebTStirrLen1;
+ xprof[3] =-xprof[2];
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[1];
+ xprof[5] =-xprof[0];
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr3Sh->DefineSection(0, 0);
+ forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);
+
+ TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);
+
+ yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
+ yprof[7] = yprof[6];
+
+ forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr4Sh->DefineSection(0, 0);
+ forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);
+
+ // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
+ TGeoXtru *frWebClampSh = new TGeoXtru(2);
+
+ xprof[0] = kFRWebClampIntWide/2;
+ yprof[0] = kFRWebClampIntHi;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = kFRWebClampExtWide/2;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = kFRWebClampExtHi;
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ frWebClampSh->DefinePolygon(8, xprof, yprof);
+ frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
+ frWebClampSh->DefineSection(1, kFRWebClampThick/2);
+
+ // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
+ TGeoXtru *upWebStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
+ xprof[3] = xprof[2] - kRearUpWebStirrThick;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearUpWebStirrH1;
+ xprof[5] = xprof[4] + kRearUpWebStirrWide;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[5] + kRearUpWebStirrH2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ upWebStirrSh->DefinePolygon(8, xprof, yprof);
+ upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
+ upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);
+
+ // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
+ TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
+ kRearUpWebBarHi/2,
+ kRearUpWebBarThick/2);
+
+ // The Webcam: a BBox
+ TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
+ kWebcamLength/2,
+ kFRWebClampIntHi/2);
+
+ // The Upper Wheel Slide (0872/C/Z/00-01-02)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
+ // (a Pcon) (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *upSlideAirSh = new TGeoXtru(2);
+ upSlideAirSh->SetName("ITSupperSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0];
+ yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
+ xprof[2] = xprof[1] - kUpperSlideIntDepth;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideTotHeight;
+ xprof[4] = xprof[3] + kUpperSlideTotDepth;
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[0];
+
+ upSlideAirSh->DefinePolygon(6, xprof, yprof);
+ upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
+ upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *upSlideAluSh = new TGeoXtru(2);
+ upSlideAluSh->SetName("ITSupperSlideAluShape");
+
+ xprof[0] = upSlideAirSh->GetX(0);
+ yprof[0] = upSlideAirSh->GetY(0);
+ xprof[1] = upSlideAirSh->GetX(1);
+ yprof[1] = upSlideAirSh->GetY(1);
+ xprof[2] = xprof[1] - kUpperSlideStubDep;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideStubHi;
+ xprof[4] = upSlideAirSh->GetX(2);
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[4] - kUpperSlideBlockHi;
+ xprof[6] = upSlideAirSh->GetX(5);
+ yprof[6] = yprof[5];
+ xprof[7] = xprof[6];
+ yprof[7] = yprof[0];
+
+ upSlideAluSh->DefinePolygon(8, xprof, yprof);
+ upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
+ upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
+ upSlideHoleSh->SetName("ITSupperSlideHoleShape");
+
+ zpos = upSlideAluSh->GetY(5);
+ upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
+ zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
+ - 2*kUpperSlideHoleH1);
+ upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
+ zpos += kUpperSlideHoleH3;
+ upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
+ upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
+ zpos += kUpperSlideHoleH2;
+ upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
+ upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);
+
+ TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
+ new TGeoRotation("",0,-90,0) );
+ upSlideHolePos->SetName("ITSupperSlideHolePos");
+ upSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
+ upSlidePinSh->SetName("ITSupperSlidePinShape");
+
+ zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
+ + kUpperSlidePinH3 - kUpperSlideBlockHi);
+ upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH3;
+ upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
+ upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
+ zpos += kUpperSlidePinH2;
+ upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
+ upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH1;
+ upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);
+
+ // The Lower Wheel Slide (0872/C/W/00-01-02-03)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
+ // (a Xtru) and the Steel pin (a Pcon)
+ // (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
+ lwSlideAirSh->SetName("ITSlowerSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
+ xprof[3] = xprof[2] - kLowerSlideTotDepth;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ lwSlideAirSh->DefinePolygon(6, xprof, yprof);
+ lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
+ lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
+ lwSlideAluSh->SetName("ITSlowerSlideAluShape");
+
+ xprof[0] = lwSlideAirSh->GetX(0);
+ yprof[0] = lwSlideAirSh->GetY(0);
+ xprof[1] = lwSlideAirSh->GetX(1);
+ yprof[1] = lwSlideAirSh->GetY(1);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kLowerSlideBlockHi;
+ xprof[3] = lwSlideAirSh->GetX(3);
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlideBlockHi;
+ xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = lwSlideAirSh->GetY(4);
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ lwSlideAluSh->DefinePolygon(8, xprof, yprof);
+ lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
+ lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
+ lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");
+
+ zpos = lwSlideAluSh->GetY(2);
+ lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
+ zpos += kLowerSlideHoleH1;
+ lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
+ lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
+ zpos = lwSlideAluSh->GetY(4);
+ lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);
+
+ TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
+ 0, 0,
+ new TGeoRotation("",0,-90,0) );
+ lwSlideHolePos->SetName("ITSlowerSlideHolePos");
+ lwSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");
+
+ // The Aluminum nose: a Xtru
+ TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
+ lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");
+
+ xprof[0] = lwSlideAluSh->GetX(5);
+ yprof[0] = lwSlideAluSh->GetY(5);
+ xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
+ xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
+ yprof[3] = lwSlideAluSh->GetY(6);
+ xprof[4] = xprof[0];
+ yprof[4] = yprof[3];
+
+ lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
+ lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
+ lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
+ lwSlidePinSh->SetName("ITSlowerSlidePinShape");
+
+ zpos = lwSlideAirSh->GetY(2);
+ lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
+ zpos += kLowerSlidePinH2;
+ lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
+ lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
+ zpos += kLowerSlidePinH1;
+ lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);
+
+ // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
+ // to approximate arcs with polylines
+ TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The internal arc
+ xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
+ yprof[j] = kStirrC12R50*SinD(90*j/10);
+ }
+
+ xprof[11] = xprof[10] + kStirrC12TailLen;
+ yprof[11] = yprof[10];
+ xprof[12] = xprof[11];
+ yprof[12] = kStirrC12BodyHalfHi;
+ xprof[13] = xprof[12] - kStirrC12BodyLen;
+ yprof[13] = yprof[12];
+
+ xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
+ yprof[17] = kStirrC12HeadHalfHi;
+ IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
+ kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
+ xprof[16], yprof[16], xdummy, ydummy);
+ alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
+ xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
+ yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
+ xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
+ yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));
+
+ xprof[18] = xprof[17] - kStirrC12HeadLen;
+ yprof[18] = yprof[17];
+ xprof[19] = xprof[18];
+ yprof[19] = kStirrC12HeadIntHi;
+ xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
+ yprof[20] = yprof[19];
+ for (Int_t j=1; j<4; j++) {
+ xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
+ yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
+ }
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
+ xprof[24+jp] = xprof[23-jp];
+ yprof[24+jp] = -yprof[23-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
+ stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);
+
+ // The first element of the Stirrup on the Forward side (0872/C/05):
+ // a really complex Xtru (equal to part of the Muon Stirrup)
+ // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
+ TGeoXtru *stirrupC5Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<13; j++) { // The internal arc and the tail
+ xprof[j] = stirrupC1C2Sh->GetX(j);
+ yprof[j] = stirrupC1C2Sh->GetY(j);
+ }
+
+ xprof[13] = xprof[12] - kStirrC5BodyLen;
+ yprof[13] = yprof[12];
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < 13; jp++) {
+ xprof[14+jp] = xprof[13-jp];
+ yprof[14+jp] = -yprof[13-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC5Sh->DefinePolygon(27, xprof, yprof);
+ stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAlcoa = mgr->GetMedium("ITS_ALCOAAL$");
+ TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
+ TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medErgal = mgr->GetMedium("ITS_ERGAL$");
+ TGeoMedium *medAisi = mgr->GetMedium("ITS_AISI304L$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPlexy = mgr->GetMedium("ITS_PLEXYGLAS$");
+ TGeoMedium *medPVC = mgr->GetMedium("ITS_PVC$");
+
+
+ TGeoVolume *suppRingC2C3 = new TGeoVolume("ITSTPCsupportRingC2C3",
+ ringC2C3, medAlcoa);
+
+ suppRingC2C3->SetVisibility(kTRUE);
+ suppRingC2C3->SetLineColor(6); // Purple
+ suppRingC2C3->SetLineWidth(1);
+ suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
+ suppRingC2C3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwUpHook = new TGeoVolume("ITSTPCsupportForwUpHook",
+ forwUpHookShape, medHokotol);
+
+ forwUpHook->SetVisibility(kTRUE);
+ forwUpHook->SetLineColor(6); // Purple
+ forwUpHook->SetLineWidth(1);
+ forwUpHook->SetFillColor(forwUpHook->GetLineColor());
+ forwUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLwHook = new TGeoVolume("ITSTPCsupportForwLwHook",
+ forwLwHookShape, medHokotol);
+
+ forwLwHook->SetVisibility(kTRUE);
+ forwLwHook->SetLineColor(6); // Purple
+ forwLwHook->SetLineWidth(1);
+ forwLwHook->SetFillColor(forwLwHook->GetLineColor());
+ forwLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearUpHook = new TGeoVolume("ITSTPCsupportRearUpHook",
+ rearUpHookShape, medHokotol);
+
+ rearUpHook->SetVisibility(kTRUE);
+ rearUpHook->SetLineColor(6); // Purple
+ rearUpHook->SetLineWidth(1);
+ rearUpHook->SetFillColor(rearUpHook->GetLineColor());
+ rearUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwHook = new TGeoVolume("ITSTPCsupportRearLwHook",
+ rearLwHookShape, medAnticor);
+
+ rearLwHook->SetVisibility(kTRUE);
+ rearLwHook->SetLineColor(6); // Purple
+ rearLwHook->SetLineWidth(1);
+ rearLwHook->SetFillColor(rearLwHook->GetLineColor());
+ rearLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwBrack = new TGeoVolume("ITSTPCsupportRearLwBracket",
+ rearLwBrackShape, medAnticor);
+
+ rearLwBrack->SetVisibility(kTRUE);
+ rearLwBrack->SetLineColor(6); // Purple
+ rearLwBrack->SetLineWidth(1);
+ rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
+ rearLwBrack->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebSStirrup = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
+ forwWebSStirrSh, medAnticor);
+
+ forwWebSStirrup->SetVisibility(kTRUE);
+ forwWebSStirrup->SetLineColor(6); // Purple
+ forwWebSStirrup->SetLineWidth(1);
+ forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
+ forwWebSStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr3 = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
+ forwWebTStirr3Sh, medAnticor);
+
+ forwWebTStirr3->SetVisibility(kTRUE);
+ forwWebTStirr3->SetLineColor(6); // Purple
+ forwWebTStirr3->SetLineWidth(1);
+ forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
+ forwWebTStirr3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr4 = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
+ forwWebTStirr4Sh, medAnticor);
+
+ forwWebTStirr4->SetVisibility(kTRUE);
+ forwWebTStirr4->SetLineColor(6); // Purple
+ forwWebTStirr4->SetLineWidth(1);
+ forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
+ forwWebTStirr4->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *frWebClamp = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
+ frWebClampSh, medPlexy);
+
+ frWebClamp->SetVisibility(kTRUE);
+ frWebClamp->SetLineColor(kAzure);
+ frWebClamp->SetLineWidth(1);
+ frWebClamp->SetFillColor(frWebClamp->GetLineColor());
+ frWebClamp->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upWebStirrup = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
+ upWebStirrSh, medAnticor);
+
+ upWebStirrup->SetVisibility(kTRUE);
+ upWebStirrup->SetLineColor(6); // Purple
+ upWebStirrup->SetLineWidth(1);
+ upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
+ upWebStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upRearWebBar = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
+ upRearWebBarSh, medPlexy);
+
+ upRearWebBar->SetVisibility(kTRUE);
+ upRearWebBar->SetLineColor(kAzure);
+ upRearWebBar->SetLineWidth(1);
+ upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
+ upRearWebBar->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *webCam = new TGeoVolume("ITSTPCsupportWebcam",
+ webcamShape, medPVC);
+
+ webCam->SetVisibility(kTRUE);
+ webCam->SetLineColor(kBlack);
+ webCam->SetLineWidth(1);
+ webCam->SetFillColor(webCam->GetLineColor());
+ webCam->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlideVol = new TGeoVolume("ITSTPCsupportUpperSlide",
+ upSlideAirSh, medAir);
+
+ upSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *upSlideBlock = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
+ upSlideBlockSh, medAnticor);
+
+ upSlideBlock->SetVisibility(kTRUE);
+ upSlideBlock->SetLineColor(6); // Purple
+ upSlideBlock->SetLineWidth(1);
+ upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
+ upSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlidePin = new TGeoVolume("ITSTPCsupportUpperSlidePin",
+ upSlidePinSh, medAisi);
+
+ upSlidePin->SetVisibility(kTRUE);
+ upSlidePin->SetLineColor(kGray);
+ upSlidePin->SetLineWidth(1);
+ upSlidePin->SetFillColor(upSlidePin->GetLineColor());
+ upSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideVol = new TGeoVolume("ITSTPCsupportLowerSlide",
+ lwSlideAirSh, medAir);
+
+ lwSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *lwSlideBlock = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
+ lwSlideBlockSh, medAnticor);
+
+ lwSlideBlock->SetVisibility(kTRUE);
+ lwSlideBlock->SetLineColor(6); // Purple
+ lwSlideBlock->SetLineWidth(1);
+ lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
+ lwSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideNose = new TGeoVolume("ITSTPCsupportLowerSlideNose",
+ lwSlideNoseSh, medAnticor);
+
+ lwSlideNose->SetVisibility(kTRUE);
+ lwSlideNose->SetLineColor(6); // Purple
+ lwSlideNose->SetLineWidth(1);
+ lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
+ lwSlideNose->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlidePin = new TGeoVolume("ITSTPCsupportLowerSlidePin",
+ lwSlidePinSh, medAisi);
+
+ lwSlidePin->SetVisibility(kTRUE);
+ lwSlidePin->SetLineColor(kGray);
+ lwSlidePin->SetLineWidth(1);
+ lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
+ lwSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC1C2 = new TGeoVolume("ITSTPCsupportStirrupC1C2",
+ stirrupC1C2Sh, medErgal);
+
+ stirrC1C2->SetVisibility(kTRUE);
+ stirrC1C2->SetLineColor(6); // Purple
+ stirrC1C2->SetLineWidth(1);
+ stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
+ stirrC1C2->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC5 = new TGeoVolume("ITSTPCsupportStirrupC5",
+ stirrupC5Sh, medErgal);
+
+ stirrC5->SetVisibility(kTRUE);
+ stirrC5->SetLineColor(6); // Purple
+ stirrC5->SetLineWidth(1);
+ stirrC5->SetFillColor(stirrC5->GetLineColor());
+ stirrC5->SetFillStyle(4000); // 0% transparent
+
+
+ // Build up the wheel slides
+ upSlideVol->AddNode(upSlideBlock,1,0);
+ upSlideVol->AddNode(upSlidePin, 1,
+ new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+ lwSlideVol->AddNode(lwSlideBlock,1,0);
+ lwSlideVol->AddNode(lwSlideNose ,1,0);
+ lwSlideVol->AddNode(lwSlidePin, 1,
+ new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+
+ // Finally put everything in the mother volume
+ moth->AddNode(suppRingC2C3,1,
+ new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
+ moth->AddNode(suppRingC2C3,2,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,0.) ) );
+ moth->AddNode(suppRingC2C3,3,
+ new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
+ new TGeoRotation("",0.,0.,180.) ) );
+ moth->AddNode(suppRingC2C3,4,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwUpHook,1,
+ new TGeoTranslation( 0, 0, zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwLwHook,1,
+ new TGeoCombiTrans( 0, 0, zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
+ moth->AddNode(rearUpHook,1,
+ new TGeoTranslation( 0, 0,-zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
+ moth->AddNode(rearLwHook,1,
+ new TGeoCombiTrans( 0, 0,-zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ xpos = kRearLwHookWide/2 + kRearLwBracketThick/2;
+ ypos = -kRingCHeight;
+ moth->AddNode(rearLwBrack,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(rearLwBrack,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ xpos = kForwUpHookWide/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwWebSStirrup,1,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+ xpos = kForwLwHookWide/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
+ moth->AddNode(forwWebSStirrup,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ xpos = kForwUpHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
+ zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
+ moth->AddNode(forwWebTStirr3,1,
+ new TGeoTranslation( xpos, ypos, zpos) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,1,
+ new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,1,
+ new TGeoTranslation( xpos, ypos,
+ zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kForwLwHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
+ moth->AddNode(forwWebTStirr4,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 180., 0., 0.) ) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,2,
+ new TGeoTranslation( xpos,-ypos,
+ zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
+ ypos = kRingCHeight;
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upWebStirrup,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upWebStirrup,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+
+ ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
+ zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
+ - upRearWebBarSh->GetDZ();
+ moth->AddNode(upRearWebBar,1,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ zpos -= upRearWebBarSh->GetDZ();
+ moth->AddNode(frWebClamp,3,
+ new TGeoCombiTrans( 0, ypos,-zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ zpos -= webcamShape->GetDZ();
+ moth->AddNode(webCam,3,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14);
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upSlideVol,1,
+ new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,2,
+ new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,3,
+ new TGeoCombiTrans( xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(upSlideVol,4,
+ new TGeoCombiTrans(-xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ moth->AddNode(lwSlideVol,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,2,
+ new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,3,
+ new TGeoCombiTrans( xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+ moth->AddNode(lwSlideVol,4,
+ new TGeoCombiTrans(-xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
+ moth->AddNode(stirrC1C2,1,
+ new TGeoTranslation( xpos, 0, zpos) );
+ moth->AddNode(stirrC1C2,2,
+ new TGeoCombiTrans(-xpos, 0, zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+ xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14); // Slides are all at the same height
+ zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
+ moth->AddNode(upSlideVol,5,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,6,
+ new TGeoCombiTrans(-xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,5,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,6,
+ new TGeoCombiTrans(-xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
+ moth->AddNode(stirrC5,1,
+ new TGeoTranslation( xpos, 0,-zpos) );
+ moth->AddNode(stirrC5,2,
+ new TGeoCombiTrans(-xpos, 0,-zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+
+ return;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff