X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySupport.cxx;h=a4f2e2d4d86cebf63010c416feac49dca3c3f007;hb=47791468b84db3988e4115a27693750a86b571b6;hp=13fafaf03b8be0c29bc472e6dd64f11f575c3d28;hpb=aa177c73abd211aa4aa98acf3e1da98c0ad6c36c;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySupport.cxx b/ITS/AliITSv11GeometrySupport.cxx index 13fafaf03b8..a4f2e2d4d86 100644 --- a/ITS/AliITSv11GeometrySupport.cxx +++ b/ITS/AliITSv11GeometrySupport.cxx @@ -42,7 +42,7 @@ ClassImp(AliITSv11GeometrySupport) #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 @@ -58,6 +58,9 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) // // 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 @@ -65,7 +68,7 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) // Dimensions of the Central shield - const Double_t kHalfLengthCentral = 400.*fgkmm; + const Double_t kHalfLengthCentral = 399.9*fgkmm; const Double_t kThicknessCentral = 0.4*fgkmm; const Double_t kInnerRadiusCentral = 8.1475*fgkcm; const Double_t kOuterRadiusCentral = 9.9255*fgkcm; @@ -73,6 +76,12 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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; @@ -88,9 +97,15 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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; @@ -100,15 +115,17 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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 @@ -117,21 +134,16 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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], @@ -148,37 +160,190 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) xshld[ 0], yshld[ 0], kThicknessCentral, xair[23], yair[23]); - // Create the air shape - TGeoXtru *centralairshape = new TGeoXtru(2); - - centralairshape->DefinePolygon(24,xair,yair); - centralairshape->DefineSection(0,-kHalfLengthCentral); - centralairshape->DefineSection(1, kHalfLengthCentral); + // Then use them to determine the Omega shape points + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); - // Create the Omega insert - TGeoXtru *centralomegashape = new TGeoXtru(2); + // Finally create the single Xtru volumes + TGeoXtru *uppershape = new TGeoXtru(2); + uppershape->SetName("upTS"); - CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + for (Int_t j=0; j<6; j++) { + xXtru[j ] = xair[11-j]; + yXtru[j ] = yair[11-j]; + xXtru[j+6] = xshld[j+6]; + yXtru[j+6] = yshld[j+6]; + } + yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield + for (Int_t j=0; j<12; j++) { + xXtru[23-j] = -xXtru[j]; + yXtru[23-j] = yXtru[j]; + } - centralomegashape->DefinePolygon(48,xomega,yomega); - centralomegashape->DefineSection(0,-kHalfLengthCentral); - centralomegashape->DefineSection(1, kHalfLengthCentral); + uppershape->DefinePolygon(24,xXtru,yXtru); + uppershape->DefineSection(0,-kHalfLengthCentral); + uppershape->DefineSection(1, kHalfLengthCentral); - // The end cap half shield: a half tube of carbon fiber, - // a similar but proportionally smaller half tube of air inside it, - // and a Omega-shaped carbon fiber insert inside the air. - // They are all XTru shapes + TGeoXtru *lowershape = new TGeoXtru(2); + lowershape->SetName("lwTS"); - TGeoXtru *endcapshape = new TGeoXtru(2); + for (Int_t j=0; j<6; j++) { + xXtru[j ] = xshld[j]; + yXtru[j ] = yshld[j]; + xXtru[j+6] = xair[5-j]; + yXtru[j+6] = yair[5-j]; + } + yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield + for (Int_t j=0; j<12; j++) { + xXtru[23-j] = -xXtru[j]; + yXtru[23-j] = yXtru[j]; + } + lowershape->DefinePolygon(24,xXtru,yXtru); + lowershape->DefineSection(0,-kHalfLengthCentral); + lowershape->DefineSection(1, kHalfLengthCentral); + + yomega[10] = yshld[6]; // Add also base thickness + yomega[11] = yomega[10]; + yomega[36] = yshld[17]; + yomega[37] = yomega[36]; + + TGeoXtru *omegashape = new TGeoXtru(2); + omegashape->SetName("omTS"); + + omegashape->DefinePolygon(48,xomega,yomega); + omegashape->DefineSection(0,-kHalfLengthCentral); + omegashape->DefineSection(1, kHalfLengthCentral); + + // And now the holes and their position matrices + Double_t radius = 0.5*(uppershape->GetY(11)+lowershape->GetY(0)); + + TGeoBBox *manifhole = new TGeoBBox(kCoolManifHoleWid/2, + 0.55*(uppershape->GetY(11)-lowershape->GetY(0)), + kCoolManifHoleLen/2); + manifhole->SetName("mhTS"); + + zpos = kCoolManifHoleZPos; + + TGeoTranslation *m1p = new TGeoTranslation("m1p",0,radius, zpos); + TGeoTranslation *m1n = new TGeoTranslation("m1n",0,radius,-zpos); + m1p->RegisterYourself(); + m1n->RegisterYourself(); + + TGeoCombiTrans *m2p = new TGeoCombiTrans("m2p",radius*SinD(kThetaDeg), + radius*CosD(kThetaDeg), + zpos, + new TGeoRotation("",-kThetaDeg,0,0)); + TGeoCombiTrans *m2n = new TGeoCombiTrans("m2n",radius*SinD(kThetaDeg), + radius*CosD(kThetaDeg), + -zpos, + new TGeoRotation("",-kThetaDeg,0,0)); + m2p->RegisterYourself(); + m2n->RegisterYourself(); + + TGeoCombiTrans *m3p = new TGeoCombiTrans("m3p",radius*SinD(-kThetaDeg), + radius*CosD(-kThetaDeg), + zpos, + new TGeoRotation("",kThetaDeg,0,0)); + TGeoCombiTrans *m3n = new TGeoCombiTrans("m3n",radius*SinD(-kThetaDeg), + radius*CosD(-kThetaDeg), + -zpos, + new TGeoRotation("",kThetaDeg,0,0)); + m3p->RegisterYourself(); + m3n->RegisterYourself(); + + TGeoCombiTrans *m4p = new TGeoCombiTrans("m4p",radius*SinD(2*kThetaDeg), + radius*CosD(2*kThetaDeg), + zpos, + new TGeoRotation("",-2*kThetaDeg,0,0)); + TGeoCombiTrans *m4n = new TGeoCombiTrans("m4n",radius*SinD(2*kThetaDeg), + radius*CosD(2*kThetaDeg), + -zpos, + new TGeoRotation("",-2*kThetaDeg,0,0)); + m4p->RegisterYourself(); + m4n->RegisterYourself(); + + TGeoCombiTrans *m5p = new TGeoCombiTrans("m5p",radius*SinD(-2*kThetaDeg), + radius*CosD(-2*kThetaDeg), + zpos, + new TGeoRotation("",2*kThetaDeg,0,0)); + TGeoCombiTrans *m5n = new TGeoCombiTrans("m5n",radius*SinD(-2*kThetaDeg), + radius*CosD(-2*kThetaDeg), + -zpos, + new TGeoRotation("",2*kThetaDeg,0,0)); + m5p->RegisterYourself(); + m5n->RegisterYourself(); + + TGeoBBox *supphole = new TGeoBBox(kCoolSuppHoleWid/2, + 0.55*(uppershape->GetY(11)-lowershape->GetY(0)), + kCoolSuppHoleLen/2); + supphole->SetName("shTS"); + + zpos = kCoolSuppHoleZPos; + + TGeoTranslation *s1p = new TGeoTranslation("s1p",0,radius, zpos); + TGeoTranslation *s1n = new TGeoTranslation("s1n",0,radius,-zpos); + s1p->RegisterYourself(); + s1n->RegisterYourself(); + + TGeoCombiTrans *s2p = new TGeoCombiTrans("s2p",radius*SinD(kThetaDeg), + radius*CosD(kThetaDeg), + zpos, + new TGeoRotation("",-kThetaDeg,0,0)); + TGeoCombiTrans *s2n = new TGeoCombiTrans("s2n",radius*SinD(kThetaDeg), + radius*CosD(kThetaDeg), + -zpos, + new TGeoRotation("",-kThetaDeg,0,0)); + s2p->RegisterYourself(); + s2n->RegisterYourself(); + + TGeoCombiTrans *s3p = new TGeoCombiTrans("s3p",radius*SinD(-kThetaDeg), + radius*CosD(-kThetaDeg), + zpos, + new TGeoRotation("",kThetaDeg,0,0)); + TGeoCombiTrans *s3n = new TGeoCombiTrans("s3n",radius*SinD(-kThetaDeg), + radius*CosD(-kThetaDeg), + -zpos, + new TGeoRotation("",kThetaDeg,0,0)); + s3p->RegisterYourself(); + s3n->RegisterYourself(); + + TGeoCombiTrans *s4p = new TGeoCombiTrans("s4p",radius*SinD(2*kThetaDeg), + radius*CosD(2*kThetaDeg), + zpos, + new TGeoRotation("",-2*kThetaDeg,0,0)); + TGeoCombiTrans *s4n = new TGeoCombiTrans("s4n",radius*SinD(2*kThetaDeg), + radius*CosD(2*kThetaDeg), + -zpos, + new TGeoRotation("",-2*kThetaDeg,0,0)); + s4p->RegisterYourself(); + s4n->RegisterYourself(); + + TGeoCombiTrans *s5p = new TGeoCombiTrans("s5p",radius*SinD(-2*kThetaDeg), + radius*CosD(-2*kThetaDeg), + zpos, + new TGeoRotation("",2*kThetaDeg,0,0)); + TGeoCombiTrans *s5n = new TGeoCombiTrans("s5n",radius*SinD(-2*kThetaDeg), + radius*CosD(-2*kThetaDeg), + -zpos, + new TGeoRotation("",2*kThetaDeg,0,0)); + s5p->RegisterYourself(); + s5n->RegisterYourself(); + + // Finally the actual shape + TGeoCompositeShape *centralshape = new TGeoCompositeShape("centralTS", + "upTS+lwTS+omTS-mhTS:m1p-mhTS:m1n-mhTS:m2p-mhTS:m2n-mhTS:m3p-mhTS:m3n-mhTS:m4p-mhTS:m4n-mhTS:m5p-mhTS:m5n-shTS:s1p-shTS:s1n-shTS:s2p-shTS:s2n-shTS:s3p-shTS:s3n-shTS:s4p-shTS:s4n-shTS:s5p-shTS:s5n"); + + // The end cap half shield: a Composite Shape of carbon fiber. + // We need Composite Shapes because we have elements partially + // entering the empty spaces, and this would create overlaps or + // extrusions. + // All Composite elements are XTru shapes + + // First determine the external shape points CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap, kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap, kTheta,xshld,yshld); - endcapshape->DefinePolygon(24,xshld,yshld); - endcapshape->DefineSection(0,-kHalfLengthEndCap); - endcapshape->DefineSection(1, kHalfLengthEndCap); - // Now rescale to get the air volume dimensions InsidePoint(xshld[23], yshld[23], xshld[ 0], yshld[ 0], @@ -195,45 +360,285 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) xshld[ 0], yshld[ 0], kThicknessEndCap, xair[23], yair[23]); - // Create the air shape - TGeoXtru *endcapairshape = new TGeoXtru(2); + // Then use them to determine the Omega shape points + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + + // Finally create the single Xtru volumes + TGeoXtru *upendcapshape = new TGeoXtru(2); + upendcapshape->SetName("upEC"); + + for (Int_t j=0; j<6; j++) { + xXtru[j ] = xair[11-j]; + yXtru[j ] = yair[11-j]; + xXtru[j+6] = xshld[j+6]; + yXtru[j+6] = yshld[j+6]; + } + yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield + for (Int_t j=0; j<12; j++) { + xXtru[23-j] = -xXtru[j]; + yXtru[23-j] = yXtru[j]; + } - endcapairshape->DefinePolygon(24,xair,yair); - endcapairshape->DefineSection(0,-kHalfLengthEndCap); - endcapairshape->DefineSection(1, kHalfLengthEndCap); + upendcapshape->DefinePolygon(24,xXtru,yXtru); + upendcapshape->DefineSection(0,-kHalfLengthEndCap); + upendcapshape->DefineSection(1, kHalfLengthEndCap); - // Create the Omega insert - TGeoXtru *endcapomegashape = new TGeoXtru(2); + TGeoXtru *lowendcapshape = new TGeoXtru(2); + lowendcapshape->SetName("lwEC"); - CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + for (Int_t j=0; j<6; j++) { + xXtru[j ] = xshld[j]; + yXtru[j ] = yshld[j]; + xXtru[j+6] = xair[5-j]; + yXtru[j+6] = yair[5-j]; + } + yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield + for (Int_t j=0; j<12; j++) { + xXtru[23-j] = -xXtru[j]; + yXtru[23-j] = yXtru[j]; + } - endcapomegashape->DefinePolygon(48,xomega,yomega); - endcapomegashape->DefineSection(0,-kHalfLengthEndCap); - endcapomegashape->DefineSection(1, kHalfLengthEndCap); + lowendcapshape->DefinePolygon(24,xXtru,yXtru); + lowendcapshape->DefineSection(0,-kHalfLengthEndCap); + lowendcapshape->DefineSection(1, kHalfLengthEndCap); - // The cone half shield is more complex since there is no basic - // TGeo shape to describe it correctly. So it is made of a series - // of TGeoArb8 shapes filled with air, which all together make up the - // the cone AND its internal insert. Part of the following code is - // adapted from SPDThermalSheald method. + yomega[10] = yshld[6]; // Add also base thickness + yomega[11] = yomega[10]; + yomega[36] = yshld[17]; + yomega[37] = yomega[36]; + + TGeoXtru *omgendcapshape = new TGeoXtru(2); + omgendcapshape->SetName("omEC"); + + omgendcapshape->DefinePolygon(48,xomega,yomega); + omgendcapshape->DefineSection(0,-kHalfLengthEndCap); + omgendcapshape->DefineSection(1, kHalfLengthEndCap); + + // Finally the actual shape + TGeoCompositeShape *endcapshape = new TGeoCompositeShape("endcapTS", + "upEC+lwEC+omEC"); + + // The filler block: a Xtru + TGeoXtru *fillershape = new TGeoXtru(2); + + xXtru[0] = omgendcapshape->GetX(1) + 0.0002; // Avoid thiny extrusion + yXtru[0] = omgendcapshape->GetY(1); + xXtru[1] = omgendcapshape->GetX(0) + 0.0002; + yXtru[1] = omgendcapshape->GetY(0); + xXtru[2] = omgendcapshape->GetX(47) - 0.0002; + yXtru[2] = omgendcapshape->GetY(47); + xXtru[3] = omgendcapshape->GetX(46); + yXtru[3] = omgendcapshape->GetY(46); + + fillershape->DefinePolygon(4,xXtru,yXtru); + fillershape->DefineSection(0,-kFillerBlockLength/2); + fillershape->DefineSection(1, kFillerBlockLength/2); + + // The hole in the filler: a Tube (made of air) + TGeoTube *fillerholeshape = new TGeoTube(0, kFillerBlockHoleR, + kFillerBlockLength/2); + + // The filler bar: a BBox + Double_t fside = omgendcapshape->GetY(14) - omgendcapshape->GetY(13); + TGeoBBox *fillbarshape = new TGeoBBox(fside/2, fside/2, kFillerBarLength/2); - // Filled portions - TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone); - TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone); + // The hole in the bar filler: a smaller BBox (made of air) + fside -= 2*kFillerBarThick; + TGeoBBox *fillbarholeshape = new TGeoBBox(fside/2, fside/2, + kFillerBarLength/2); + // The cone half shield is more complex since there is no basic + // TGeo shape to describe it correctly. So it is a Composite Shape + // of a series of TGeoArb8 shapes, in which TGeoArb8 shapes filled + // with air are placed, which all together make up the cone AND + // its internal insert. Part of the following code is adapted from + // old SPDThermalSheald method. + + // sCn : Filled portions, sChn : Air holes + TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC3 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC4 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC5 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC6 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC7 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC8 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC9 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone); + + sC1->SetName("sC1"); + sC2->SetName("sC2"); + sC3->SetName("sC3"); + sC4->SetName("sC4"); + sC5->SetName("sC5"); + sC6->SetName("sC6"); + sC7->SetName("sC7"); + sC8->SetName("sC8"); + sC9->SetName("sC9"); + sC10->SetName("sC10"); + sC11->SetName("sC11"); + + TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh3 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh4 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh5 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh6 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh7 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh8 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh9 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone); + + sCh1->SetName("sCh1"); + sCh2->SetName("sCh2"); + sCh3->SetName("sCh3"); + sCh4->SetName("sCh4"); + sCh5->SetName("sCh5"); + sCh6->SetName("sCh6"); + sCh7->SetName("sCh7"); + sCh8->SetName("sCh8"); + sCh9->SetName("sCh9"); + sCh10->SetName("sCh10"); + sCh11->SetName("sCh11"); + + // Smaller end: determine the coordinates of the points of carbon fiber CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral, kOuterACentral,kOuterBCentral,kOuterRadiusCentral, kTheta,xshld,yshld); - sC1->SetVertex(0,xshld[12],yshld[12]); - sC1->SetVertex(1,xshld[11],yshld[11]); - sC1->SetVertex(2,xshld[ 0],yshld[ 0]); - sC1->SetVertex(3,xshld[23],yshld[23]); + sC1->SetVertex(0, xshld[12], yshld[12]); + sC1->SetVertex(1, xshld[11], yshld[11]); + sC1->SetVertex(2, xshld[ 0], yshld[ 0]); + sC1->SetVertex(3, xshld[23], yshld[23]); + + sC2->SetVertex(0, xshld[11], yshld[11]); + sC2->SetVertex(1, xshld[10], yshld[10]); + sC2->SetVertex(2, xshld[ 1], yshld[ 1]); + sC2->SetVertex(3, xshld[ 0], yshld[ 0]); + + sC3->SetVertex(0, xshld[10], yshld[10]); + sC3->SetVertex(1, xshld[ 9], yshld[ 9]); + sC3->SetVertex(2, xshld[ 2], yshld[ 2]); + sC3->SetVertex(3, xshld[ 1], yshld[ 1]); + + sC4->SetVertex(0, xshld[ 9], yshld[ 9]); + sC4->SetVertex(1, xshld[ 8], yshld[ 8]); + sC4->SetVertex(2, xshld[ 3], yshld[ 3]); + sC4->SetVertex(3, xshld[ 2], yshld[ 2]); + + sC5->SetVertex(0, xshld[ 8], yshld[ 8]); + sC5->SetVertex(1, xshld[ 7], yshld[ 7]); + sC5->SetVertex(2, xshld[ 4], yshld[ 4]); + sC5->SetVertex(3, xshld[ 3], yshld[ 3]); + + sC6->SetVertex(0, xshld[ 7], yshld[ 7]); + sC6->SetVertex(1, xshld[ 6], yshld[ 6]); + sC6->SetVertex(2, xshld[ 5], yshld[ 5]); + sC6->SetVertex(3, xshld[ 4], yshld[ 4]); + + sC7->SetVertex(0,-xshld[10], yshld[10]); + sC7->SetVertex(1,-xshld[11], yshld[11]); + sC7->SetVertex(2,-xshld[ 0], yshld[ 0]); + sC7->SetVertex(3,-xshld[ 1], yshld[ 1]); + + sC8->SetVertex(0,-xshld[ 9], yshld[ 9]); + sC8->SetVertex(1,-xshld[10], yshld[10]); + sC8->SetVertex(2,-xshld[ 1], yshld[ 1]); + sC8->SetVertex(3,-xshld[ 2], yshld[ 2]); + + sC9->SetVertex(0,-xshld[ 8], yshld[ 8]); + sC9->SetVertex(1,-xshld[ 9], yshld[ 9]); + sC9->SetVertex(2,-xshld[ 2], yshld[ 2]); + sC9->SetVertex(3,-xshld[ 3], yshld[ 3]); + + sC10->SetVertex(0,-xshld[ 7], yshld[ 7]); + sC10->SetVertex(1,-xshld[ 8], yshld[ 8]); + sC10->SetVertex(2,-xshld[ 3], yshld[ 3]); + sC10->SetVertex(3,-xshld[ 4], yshld[ 4]); + + sC11->SetVertex(0,-xshld[ 6], yshld[ 6]); + sC11->SetVertex(1,-xshld[ 7], yshld[ 7]); + sC11->SetVertex(2,-xshld[ 4], yshld[ 4]); + sC11->SetVertex(3,-xshld[ 5], yshld[ 5]); + + // Then rescale to get the air volume dimensions + InsidePoint(xshld[23], yshld[23], + xshld[ 0], yshld[ 0], + xshld[ 1], yshld[ 1], kThicknessCone, + xair[0], yair[0]); + for (Int_t i=1; i<23; i++) { + InsidePoint(xshld[i-1], yshld[i-1], + xshld[ i ], yshld[ i ], + xshld[i+1], yshld[i+1], kThicknessCone, + xair[i], yair[i]); + } + InsidePoint(xshld[22], yshld[22], + xshld[23], yshld[23], + xshld[ 0], yshld[ 0], kThicknessCone, + xair[23], yair[23]); + + // Then use them to determine the Omega shape points + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); - sC2->SetVertex(0,xshld[11],yshld[11]); - sC2->SetVertex(1,xshld[10],yshld[10]); - sC2->SetVertex(2,xshld[ 1],yshld[ 1]); - sC2->SetVertex(3,xshld[ 0],yshld[ 0]); + // Finally fill the small end coordinates of the air shapes + sCh1->SetVertex(0, xomega[ 0], yomega[ 0]); + sCh1->SetVertex(1, xomega[ 1], yomega[ 1]); + sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]); + sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]); + + sCh2->SetVertex(0, xomega[20], yomega[20]); + sCh2->SetVertex(1, xomega[21], yomega[21]); + sCh2->SetVertex(2, xomega[22], yomega[22]); + sCh2->SetVertex(3, xomega[23], yomega[23]); + + sCh3->SetVertex(0, xomega[ 2], yomega[ 2]); + sCh3->SetVertex(1, xomega[ 3], yomega[ 3]); + sCh3->SetVertex(2, xomega[ 4], yomega[ 4]); + sCh3->SetVertex(3, xomega[ 5], yomega[ 5]); + + sCh4->SetVertex(0, xomega[16], yomega[16]); + sCh4->SetVertex(1, xomega[17], yomega[17]); + sCh4->SetVertex(2, xomega[18], yomega[18]); + sCh4->SetVertex(3, xomega[19], yomega[19]); + + sCh5->SetVertex(0, xomega[ 6], yomega[ 6]); + sCh5->SetVertex(1, xomega[ 7], yomega[ 7]); + sCh5->SetVertex(2, xomega[ 8], yomega[ 8]); + sCh5->SetVertex(3, xomega[ 9], yomega[ 9]); + + sCh6->SetVertex(0, xomega[12], yomega[12]); + sCh6->SetVertex(1, xomega[13], yomega[13]); + sCh6->SetVertex(2, xomega[14], yomega[14]); + sCh6->SetVertex(3, xomega[15], yomega[15]); + + sCh7->SetVertex(0,-xomega[21], yomega[21]); + sCh7->SetVertex(1,-xomega[20], yomega[20]); + sCh7->SetVertex(2,-xomega[23], yomega[23]); + sCh7->SetVertex(3,-xomega[22], yomega[22]); + + sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]); + sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]); + sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]); + sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]); + + sCh9->SetVertex(0,-xomega[17], yomega[17]); + sCh9->SetVertex(1,-xomega[16], yomega[16]); + sCh9->SetVertex(2,-xomega[19], yomega[19]); + sCh9->SetVertex(3,-xomega[18], yomega[18]); + + sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]); + sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]); + sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]); + sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]); + + sCh11->SetVertex(0,-xomega[13], yomega[13]); + sCh11->SetVertex(1,-xomega[12], yomega[12]); + sCh11->SetVertex(2,-xomega[15], yomega[15]); + sCh11->SetVertex(3,-xomega[14], yomega[14]); + + // Bigger end: determine the coordinates of the points of carbon fiber // Drawings give only the radius, convert it to the apothegm Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone @@ -241,67 +646,143 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone - 0.25*kOuterACone*kOuterACone); - Double_t xco[4], yco[4], xci[4], yci[4]; - - for (Int_t i=0; i<2; i++) { - Double_t th = i*kTheta*TMath::RadToDeg(); - xco[2*i ] = kOuterRadiusCone*SinD(th) - 0.5*kOuterACone*CosD(th); - yco[2*i ] = kOuterRadiusCone*CosD(th) + 0.5*kOuterACone*SinD(th); - xci[2*i ] = kInnerRadiusCone*SinD(th) - 0.5*kInnerACone*CosD(th); - yci[2*i ] = kInnerRadiusCone*CosD(th) + 0.5*kInnerACone*SinD(th); - xco[2*i+1] = kOuterRadiusCone*SinD(th) + 0.5*kOuterACone*CosD(th); - yco[2*i+1] = kOuterRadiusCone*CosD(th) - 0.5*kOuterACone*SinD(th); - xci[2*i+1] = kInnerRadiusCone*SinD(th) + 0.5*kInnerACone*CosD(th); - yci[2*i+1] = kInnerRadiusCone*CosD(th) - 0.5*kInnerACone*SinD(th); - } + CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone, + kOuterACone,kOuterBCone,kOuterRadiusCone, + kTheta,xshld,yshld); - sC1->SetVertex(4,xco[0],yco[0]); - sC1->SetVertex(5,xco[1],yco[1]); - sC1->SetVertex(6,xci[1],yci[1]); - sC1->SetVertex(7,xci[0],yci[0]); - - sC2->SetVertex(4,xco[1],yco[1]); - sC2->SetVertex(5,xco[2],yco[2]); - sC2->SetVertex(6,xci[2],yci[2]); - sC2->SetVertex(7,xci[1],yci[1]); - - // Air holes - TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone); - TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone); - - for(Int_t i=0; i<4; i++){ - InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0], - sC1->GetVertices()[((i+3)%4)*2+1], - sC1->GetVertices()[i*2+0], - sC1->GetVertices()[i*2+1], - sC1->GetVertices()[((i+1)%4)*2+0], - sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y); - sCh1->SetVertex(i,x,y); - - InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0], - sC1->GetVertices()[((i+3)%4 +4)*2+1], - sC1->GetVertices()[(i+4)*2+0], - sC1->GetVertices()[(i+4)*2+1], - sC1->GetVertices()[((i+1)%4 +4)*2+0], - sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y); - sCh1->SetVertex(i+4,x,y); - - InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0], - sC2->GetVertices()[((i+3)%4)*2+1], - sC2->GetVertices()[i*2+0], - sC2->GetVertices()[i*2+1], - sC2->GetVertices()[((i+1)%4)*2+0], - sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y); - sCh2->SetVertex(i,x,y); - - InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0], - sC2->GetVertices()[((i+3)%4 +4)*2+1], - sC2->GetVertices()[(i+4)*2+0], - sC2->GetVertices()[(i+4)*2+1], - sC2->GetVertices()[((i+1)%4 +4)*2+0], - sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y); - sCh2->SetVertex(i+4,x,y); + sC1->SetVertex(4, xshld[12], yshld[12]); + sC1->SetVertex(5, xshld[11], yshld[11]); + sC1->SetVertex(6, xshld[ 0], yshld[ 0]); + sC1->SetVertex(7, xshld[23], yshld[23]); + + sC2->SetVertex(4, xshld[11], yshld[11]); + sC2->SetVertex(5, xshld[10], yshld[10]); + sC2->SetVertex(6, xshld[ 1], yshld[ 1]); + sC2->SetVertex(7, xshld[ 0], yshld[ 0]); + + sC3->SetVertex(4, xshld[10], yshld[10]); + sC3->SetVertex(5, xshld[ 9], yshld[ 9]); + sC3->SetVertex(6, xshld[ 2], yshld[ 2]); + sC3->SetVertex(7, xshld[ 1], yshld[ 1]); + + sC4->SetVertex(4, xshld[ 9], yshld[ 9]); + sC4->SetVertex(5, xshld[ 8], yshld[ 8]); + sC4->SetVertex(6, xshld[ 3], yshld[ 3]); + sC4->SetVertex(7, xshld[ 2], yshld[ 2]); + + sC5->SetVertex(4, xshld[ 8], yshld[ 8]); + sC5->SetVertex(5, xshld[ 7], yshld[ 7]); + sC5->SetVertex(6, xshld[ 4], yshld[ 4]); + sC5->SetVertex(7, xshld[ 3], yshld[ 3]); + + sC6->SetVertex(4, xshld[ 7], yshld[ 7]); + sC6->SetVertex(5, xshld[ 6], yshld[ 6]); + sC6->SetVertex(6, xshld[ 5], yshld[ 5]); + sC6->SetVertex(7, xshld[ 4], yshld[ 4]); + + sC7->SetVertex(4,-xshld[10], yshld[10]); + sC7->SetVertex(5,-xshld[11], yshld[11]); + sC7->SetVertex(6,-xshld[ 0], yshld[ 0]); + sC7->SetVertex(7,-xshld[ 1], yshld[ 1]); + + sC8->SetVertex(4,-xshld[ 9], yshld[ 9]); + sC8->SetVertex(5,-xshld[10], yshld[10]); + sC8->SetVertex(6,-xshld[ 1], yshld[ 1]); + sC8->SetVertex(7,-xshld[ 2], yshld[ 2]); + + sC9->SetVertex(4,-xshld[ 8], yshld[ 8]); + sC9->SetVertex(5,-xshld[ 9], yshld[ 9]); + sC9->SetVertex(6,-xshld[ 2], yshld[ 2]); + sC9->SetVertex(7,-xshld[ 3], yshld[ 3]); + + sC10->SetVertex(4,-xshld[ 7], yshld[ 7]); + sC10->SetVertex(5,-xshld[ 8], yshld[ 8]); + sC10->SetVertex(6,-xshld[ 3], yshld[ 3]); + sC10->SetVertex(7,-xshld[ 4], yshld[ 4]); + + sC11->SetVertex(4,-xshld[ 6], yshld[ 6]); + sC11->SetVertex(5,-xshld[ 7], yshld[ 7]); + sC11->SetVertex(6,-xshld[ 4], yshld[ 4]); + sC11->SetVertex(7,-xshld[ 5], yshld[ 5]); + + // Then rescale to get the air volume dimensions + InsidePoint(xshld[23], yshld[23], + xshld[ 0], yshld[ 0], + xshld[ 1], yshld[ 1], kThicknessCone, + xair[0], yair[0]); + for (Int_t i=1; i<23; i++) { + InsidePoint(xshld[i-1], yshld[i-1], + xshld[ i ], yshld[ i ], + xshld[i+1], yshld[i+1], kThicknessCone, + xair[i], yair[i]); } + InsidePoint(xshld[22], yshld[22], + xshld[23], yshld[23], + xshld[ 0], yshld[ 0], kThicknessCone, + xair[23], yair[23]); + + // Then use them to determine the Omega shape points + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + + // Finally fill the big end coordinates of the air shapes + sCh1->SetVertex(4, xomega[ 0], yomega[ 0]); + sCh1->SetVertex(5, xomega[ 1], yomega[ 1]); + sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]); + sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]); + + sCh2->SetVertex(4, xomega[20], yomega[20]); + sCh2->SetVertex(5, xomega[21], yomega[21]); + sCh2->SetVertex(6, xomega[22], yomega[22]); + sCh2->SetVertex(7, xomega[23], yomega[23]); + + sCh3->SetVertex(4, xomega[ 2], yomega[ 2]); + sCh3->SetVertex(5, xomega[ 3], yomega[ 3]); + sCh3->SetVertex(6, xomega[ 4], yomega[ 4]); + sCh3->SetVertex(7, xomega[ 5], yomega[ 5]); + + sCh4->SetVertex(4, xomega[16], yomega[16]); + sCh4->SetVertex(5, xomega[17], yomega[17]); + sCh4->SetVertex(6, xomega[18], yomega[18]); + sCh4->SetVertex(7, xomega[19], yomega[19]); + + sCh5->SetVertex(4, xomega[ 6], yomega[ 6]); + sCh5->SetVertex(5, xomega[ 7], yomega[ 7]); + sCh5->SetVertex(6, xomega[ 8], yomega[ 8]); + sCh5->SetVertex(7, xomega[ 9], yomega[ 9]); + + sCh6->SetVertex(4, xomega[12], yomega[12]); + sCh6->SetVertex(5, xomega[13], yomega[13]); + sCh6->SetVertex(6, xomega[14], yomega[14]); + sCh6->SetVertex(7, xomega[15], yomega[15]); + + sCh7->SetVertex(4,-xomega[21], yomega[21]); + sCh7->SetVertex(5,-xomega[20], yomega[20]); + sCh7->SetVertex(6,-xomega[23], yomega[23]); + sCh7->SetVertex(7,-xomega[22], yomega[22]); + + sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]); + sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]); + sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]); + sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]); + + sCh9->SetVertex(4,-xomega[17], yomega[17]); + sCh9->SetVertex(5,-xomega[16], yomega[16]); + sCh9->SetVertex(6,-xomega[19], yomega[19]); + sCh9->SetVertex(7,-xomega[18], yomega[18]); + + sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]); + sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]); + sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]); + sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]); + + sCh11->SetVertex(4,-xomega[13], yomega[13]); + sCh11->SetVertex(5,-xomega[12], yomega[12]); + sCh11->SetVertex(6,-xomega[15], yomega[15]); + sCh11->SetVertex(7,-xomega[14], yomega[14]); + + // Now the actual carbon fiber cone: a CompositeShape + TGeoCompositeShape *sCone = new TGeoCompositeShape("sCone", + "sC1+sC2+sC3+sC4+sC5+sC6+sC7+sC8+sC9+sC10+sC11"); // Finally the carbon fiber Ring with its Wings and their // stesalite inserts. They are Tube and TubeSeg shapes @@ -336,77 +817,160 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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); @@ -428,7 +992,7 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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 @@ -440,51 +1004,56 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) // Add all volumes in the assembly - vM->AddNode(centralshield,1,0); - vM->AddNode(centralshield,2,new TGeoRotation("",180,0,0)); + const Double_t kLittleZTrans = 0.1*fgkmm; + vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans)); + vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans, + new TGeoRotation("",180,0,0))); + zpos = kHalfLengthCentral+kHalfLengthEndCap; vM->AddNode(endcapshield,1, - new TGeoTranslation(0,0, kHalfLengthCentral+kHalfLengthEndCap)); - vM->AddNode(endcapshield,2, - new TGeoTranslation(0,0,-kHalfLengthCentral-kHalfLengthEndCap)); + new TGeoTranslation(0,0, zpos-kLittleZTrans)); + vM->AddNode(endcapshield,2,new TGeoCombiTrans( + 0, 0,-zpos-kLittleZTrans, new TGeoRotation("", 0,180,0) ) ); vM->AddNode(endcapshield,3,new TGeoCombiTrans( - 0, 0, kHalfLengthCentral+kHalfLengthEndCap, - new TGeoRotation("",180,0,0) ) ); + 0, 0, zpos-kLittleZTrans, new TGeoRotation("",180, 0,0) ) ); vM->AddNode(endcapshield,4,new TGeoCombiTrans( - 0, 0,-kHalfLengthCentral-kHalfLengthEndCap, - new TGeoRotation("",180,0,0) ) ); - - for (Int_t i=0; i<10; i++) { - Double_t thetaC12 = kTheta*TMath::RadToDeg(); - vM->AddNode(vC1,2*i+1, new TGeoCombiTrans( - 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone, - new TGeoRotation("",0, 0,i*thetaC12) ) ); - vM->AddNode(vC1,2*i+2, new TGeoCombiTrans( - 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone, - new TGeoRotation("",0,180,i*thetaC12) ) ); - vM->AddNode(vC2,2*i+1, new TGeoCombiTrans( - 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone, - new TGeoRotation("",0, 0,i*thetaC12) ) ); - vM->AddNode(vC2,2*i+2, new TGeoCombiTrans( - 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone, - new TGeoRotation("",0,180,i*thetaC12) ) ); - } + 0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,180,0) ) ); + + xpos = omgendcapshape->GetX(13) + fillbarshape->GetDX(); + ypos = omgendcapshape->GetY(13) + fillbarshape->GetDY(); + zpos -= fillbarshape->GetDZ(); + vM->AddNode(fillerbar, 1, new TGeoTranslation( xpos, ypos, zpos)); + vM->AddNode(fillerbar, 2, new TGeoTranslation(-xpos, ypos, zpos)); + vM->AddNode(fillerbar, 3, new TGeoTranslation( xpos,-ypos, zpos)); + vM->AddNode(fillerbar, 4, new TGeoTranslation(-xpos,-ypos, zpos)); + vM->AddNode(fillerbar, 5, new TGeoTranslation( xpos, ypos,-zpos)); + vM->AddNode(fillerbar, 6, new TGeoTranslation(-xpos, ypos,-zpos)); + vM->AddNode(fillerbar, 7, new TGeoTranslation( xpos,-ypos,-zpos)); + vM->AddNode(fillerbar, 8, new TGeoTranslation(-xpos,-ypos,-zpos)); + + zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone; + vM->AddNode(vCone ,1, new TGeoTranslation(0, 0, zpos-kLittleZTrans)); - vM->AddNode(ring,1,new TGeoTranslation(0, 0, - kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone - +kHalfLengthRing)); - vM->AddNode(ring,2,new TGeoTranslation(0, 0, - -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone - -kHalfLengthRing)); + vM->AddNode(vCone ,2, new TGeoCombiTrans(0, 0, zpos-kLittleZTrans, + new TGeoRotation("", 0, 0, 180) )); + + vM->AddNode(vCone ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans, + new TGeoRotation("", 0, 180, 0) )); + + vM->AddNode(vCone ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans, + new TGeoRotation("", 0, 180, 180) )); + + zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone + + kHalfLengthRing; + vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans)); + vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans)); for (Int_t i=0; i<4; i++) { Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.; - vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, - kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone - +kHalfLengthRing, new TGeoRotation("",thetaW,0,0) )); - vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0, - -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone - -kHalfLengthRing, new TGeoRotation("",thetaW,0,0) )); + vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans, + new TGeoRotation("",thetaW,0,0) ) ); + vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans, + new TGeoRotation("",thetaW,0,0) ) ); } // Some debugging if requested @@ -503,7 +1072,7 @@ void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) 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 @@ -555,8 +1124,8 @@ void AliITSv11GeometrySupport::CreateSPDThermalShape( //______________________________________________________________________ void AliITSv11GeometrySupport::CreateSPDOmegaShape( - Double_t *xin, Double_t *yin, Double_t d, - Double_t *x, Double_t *y) + const Double_t *xin, const Double_t *yin, Double_t d, + Double_t *x, Double_t *y) { // // Creates the proper sequence of X and Y coordinates to determine @@ -630,7 +1199,7 @@ void AliITSv11GeometrySupport::CreateSPDOmegaShape( //______________________________________________________________________ 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 @@ -670,7 +1239,7 @@ void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b, //______________________________________________________________________ void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t d, - Double_t &x, Double_t &y) + Double_t &x, Double_t &y) const { // // Determines the X and Y of the first internal point of the Omega shape @@ -702,17 +1271,17 @@ void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1, Double_t b = (x1 - x2)*(y1 - y2); Double_t c = (y1 - y2)*(y1 - y2) - d*d; - // (Delta4 is Delta/4 because we use the reduced formula) - Double_t Delta4 = b*b - a*c; + // (delta4 is Delta/4 because we use the reduced formula) + Double_t delta4 = b*b - a*c; // Compute the slope of the two parallel lines // (one of the two possible slopes, the one with the smaller // absolute value is needed) - if (Delta4 < 0) { // Should never happen with our data, but just to be sure + if (delta4 < 0) { // Should never happen with our data, but just to be sure x = -1; // x is expected positive, so this flags an error return; } else - m = (b + TMath::Sqrt(Delta4))/a; // b is negative with our data + m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data // Finally compute the coordinates of the point x = x2 + (y1 - y2 - d)/m; @@ -726,7 +1295,7 @@ void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1, void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3, - Double_t &x, Double_t &y) + Double_t &x, Double_t &y) const { // // Given two points (x1,y1) and (x2,y2), determines the point (x,y) @@ -773,7 +1342,7 @@ void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1, } //______________________________________________________________________ -void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) +void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr) { // // Creates the SDD support cone and cylinder geometry as a @@ -789,6 +1358,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) // 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" @@ -829,7 +1399,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) 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; @@ -845,17 +1415,24 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) 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 @@ -1358,6 +1935,143 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) 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(); @@ -1420,6 +2134,30 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) 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); @@ -1444,6 +2182,30 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) 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); @@ -1479,6 +2241,14 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) // 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)); @@ -1523,7 +2293,7 @@ void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) } //______________________________________________________________________ -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 @@ -1553,7 +2323,7 @@ void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr) // of the carbon fiber cylinder was increased from 0.6 to 0.625mm // Dimensions of the Central cylinder and flanges - const Double_t kCylinderHalfLength = (1144.0/2) *fgkmm; + const Double_t kCylinderHalfLength = (1143.6/2) *fgkmm; const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm; const Double_t kCylinderThickness = 0.625*fgkmm; const Double_t kFoamHalfLength = (1020.0/2) *fgkmm; @@ -2316,7 +3086,7 @@ void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the structure supporting the ITS cable trays on Side A // @@ -3128,7 +3898,7 @@ void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SPD cable trays which are outside the ITS support cones // but still inside the TPC on Side A @@ -3141,15 +3911,17 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, // 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 cables and low voltage cables are approximated with mean -// materials and square cross sections, but preserving the total material -// budget. +// Optical fibers and voltage cables are approximated with mean materials +// and square cross sections, but preserving the total material budget. // // Overall position and rotation of the A-Side Cable Trays @@ -3170,18 +3942,27 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!! const Double_t kForwardTrayThick = 2.00 *fgkmm; - const Int_t kForwardSideNpoints = 6; + const Int_t kForwardSideNpoints = 6; const Double_t kExternalTrayLen = 1200.00 *fgkmm; const Double_t kExternalTrayWide = kForwardTrayWide; const Double_t kExternalTrayHigh = kForwardTraySecondHigh; const Double_t kExternalTrayThick = kForwardTrayThick; - const Double_t kCoolingTubeRmin = 5.00 *fgkmm; - const Double_t kCoolingTubeRmax = 6.00 *fgkmm; + const Double_t kCoolingTubeRmin = 2.00 *fgkmm; + const Double_t kCoolingTubeRmax = 3.00 *fgkmm; const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!! - const Double_t kLowVoltageCableSect = 3.412*fgkmm;//!!!ESTIMATED!!! + const Double_t 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]; @@ -3262,23 +4043,46 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, (kForwardTrayInterSpace-kExternalTrayThick)/2, kExternalTrayLen/2); - // The cooling tube inside the forward tray: a TubeSeg + // 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; - TGeoTubeSeg *coolTubeForw = new TGeoTubeSeg(kCoolingTubeRmin, - kCoolingTubeRmax, zlen, 0, 360); + 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(kCoolingTubeRmin, kCoolingTubeRmax, + TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax, kExternalTrayLen/2, 0, 360, 0, SinD(kTrayAZRot),-CosD(kTrayAZRot), 0, 0, 1); - // The optical fibers inside the forward tray: a BBox - TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2, - kOpticalFibersSect/2, - kForwardTrayTotalLen/2); + // The 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); @@ -3298,14 +4102,196 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, optFibsExt->DefineSection(0, 0); optFibsExt->DefineSection(1, kOpticalFibersSect); - // The Low Voltage cables inside the forward tray: a BBox - TGeoBBox *lowCablesForw = new TGeoBBox(kLowVoltageCableSect/2, - kLowVoltageCableSect/2, - kForwardTrayTotalLen/2); + // The Low Voltage cables inside the forward tray: two Xtru + TGeoXtru *lowCablesForwCu = new TGeoXtru(2); + + xprof[0] = -kTrayCCablesZLenOut; + yprof[0] = xprof[0]/TanD(kTrayCCablesRot); + xprof[1] = 0; + yprof[1] = 0; + xprof[2] = kForwardTrayTotalLen; + yprof[2] = yprof[1]; + xprof[3] = xprof[2]; + yprof[3] = yprof[2] + kLowVoltageCableSectCu/2; + xprof[4] = xprof[1]; + yprof[4] = yprof[3]; + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kLowVoltageCableSectCu/2; + + lowCablesForwCu->DefinePolygon(6, xprof, yprof); + lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu); + lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu); + + TGeoXtru *lowCablesForwPUR = new TGeoXtru(2); + + 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 Low Voltage inside the external tray: a Xtru - TGeoXtru *lowCablesExt = new TGeoXtru(2); - lowCablesExt->SetName("ITSsuppSPDExtTrayLowVoltage"); + // The Coaxial inside the external tray: two Xtru + TGeoXtru *coaxCablesExtCu = new TGeoXtru(2); + coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu"); yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick + 2*forwTrayWall->GetDY(); @@ -3313,20 +4299,39 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, xprof[1] = kExternalTrayLen; yprof[1] = yprof[0]; xprof[2] = xprof[1]; - yprof[2] = yprof[1] + kLowVoltageCableSect; + 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); - lowCablesExt->DefinePolygon(4, xprof, yprof); - lowCablesExt->DefineSection(0, 0); - lowCablesExt->DefineSection(1, kLowVoltageCableSect); + 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 *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!! - TGeoMedium *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$"); + 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); @@ -3427,6 +4432,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, 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); @@ -3436,6 +4450,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, 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); @@ -3454,23 +4477,113 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, extOptFibs->SetFillColor(extOptFibs->GetLineColor()); extOptFibs->SetFillStyle(4000); // 0% transparent - TGeoVolume *forwLowCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayLowCabs", - lowCablesForw, medLVC); - - forwLowCabs->SetVisibility(kTRUE); - forwLowCabs->SetLineColor(kRed); // Red - forwLowCabs->SetLineWidth(1); - forwLowCabs->SetFillColor(forwLowCabs->GetLineColor()); - forwLowCabs->SetFillStyle(4000); // 0% transparent - - TGeoVolume *extLowCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayLowCabs", - lowCablesExt, medLVC); - - extLowCabs->SetVisibility(kTRUE); - extLowCabs->SetLineColor(kRed); // Red - extLowCabs->SetLineWidth(1); - extLowCabs->SetFillColor(extLowCabs->GetLineColor()); - extLowCabs->SetFillStyle(4000); // 0% transparent + TGeoVolume *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 @@ -3515,23 +4628,48 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, 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->GetDX() + coolTubeForw->GetRmax(); - yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + optFibsForw->GetDY(); - zloc = optFibsForw->GetDZ(); + xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax(); + yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY(); cableTrayAForw->AddNode(forwOptFibs, 1, - new TGeoTranslation(xloc, yloc, zloc)); - - xloc = lowCablesForw->GetDX() + coolTubeForw->GetRmax(); - yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +lowCablesForw->GetDY(); - zloc = lowCablesForw->GetDZ(); - cableTrayAForw->AddNode(forwLowCabs, 1, - new TGeoTranslation(-xloc, yloc, zloc)); + 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; @@ -3559,22 +4697,44 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, 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 = kOpticalFibersSect + coolTubeExt->GetRmax(); + xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax(); cableTrayAExt->AddNode(extOptFibs, 1, new TGeoCombiTrans( xloc, 0, 0, new TGeoRotation("",90,-90,-90))); - xloc = kLowVoltageCableSect + coolTubeExt->GetRmax(); - cableTrayAExt->AddNode(extLowCabs, 1, + xloc = coolTubeExt->GetRmax(); + cableTrayAExt->AddNode(extLowCabsCu, 1, + new TGeoCombiTrans(-xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + cableTrayAExt->AddNode(extLowCabsPUR, 1, + new TGeoCombiTrans(-xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + + xloc = 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; @@ -3696,7 +4856,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SPD cable trays which are outside the ITS support cones // but still inside the TPC on Side C @@ -3712,14 +4872,23 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, // // 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; @@ -3730,10 +4899,17 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!! const Double_t kTrayCFoldAngle = 5.000 *fgkDegree; - const Double_t kCoolingTubeRmin = 5.000 *fgkmm; - const Double_t kCoolingTubeRmax = 6.000 *fgkmm; + const Double_t kCoolingTubeRmin = 2.000 *fgkmm; + const Double_t kCoolingTubeRmax = 3.000 *fgkmm; const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!! - const Double_t kLowVoltageCableSect = 3.412 *fgkmm;//!!!ESTIMATED!!! + const Double_t 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; @@ -3755,6 +4931,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, // The Cable Tray lower face: a Xtru TGeoXtru *sideCHorFace = new TGeoXtru(2); + sideCHorFace->SetName("ITSsuppSPDTraySideCHor"); xprof[0] = 0.; yprof[0] = 0.; @@ -3851,6 +5028,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, // The internal wall: a Xtru TGeoXtru *intWall = new TGeoXtru(2); + intWall->SetName("ITSsuppSPDTraySideCWall"); xprof[0] = sideCHorFace->GetX(5); yprof[0] = sideCHorFace->GetY(5); @@ -3871,8 +5049,10 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, // The horizontal part of the cooling tube inside the tray: a Tube delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5); - TGeoTube *horTube = new TGeoTube(kCoolingTubeRmin, kCoolingTubeRmax, - delta/2); + 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; @@ -3885,67 +5065,217 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))* (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) ); - TGeoCtub *incTube = new TGeoCtub(kCoolingTubeRmin, kCoolingTubeRmax, - delta/2, 0, 360, + 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] = sideCMidFace->GetX(5); - - yprof[0] = sideCMidFace->GetY(5); - xprof[1] = sideCMidFace->GetX(4); - yprof[1] = sideCMidFace->GetY(4); - xprof[2] = sideCMidFace->GetX(3); - yprof[2] = sideCMidFace->GetY(3); - xprof[3] = xprof[2] - kOpticalFibersSect*SinD(kTrayCFoldAngle); - yprof[3] = yprof[2] + kOpticalFibersSect*CosD(kTrayCFoldAngle); - InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], - kOpticalFibersSect , xprof[4], yprof[4]); - xprof[5] = 0.; - yprof[5] = yprof[0] + kOpticalFibersSect; + xprof[0] = -kTrayCCablesZLenOut; + yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot); + xprof[1] = sideCMidFace->GetX(5); + yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans; + xprof[2] = sideCMidFace->GetX(4); + yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans; + xprof[3] = sideCMidFace->GetX(3); + yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans; + xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle); + yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle); + InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3], + kOpticalFibersSect , xprof[5], yprof[5]); + xprof[6] = 0.; + yprof[6] = yprof[1] + kOpticalFibersSect; + xprof[7] = xprof[0]; + yprof[7] = yprof[0] + kOpticalFibersSect; - optFibs->DefinePolygon(6, xprof, yprof); + optFibs->DefinePolygon(8, xprof, yprof); optFibs->DefineSection(0, 0); optFibs->DefineSection(1, kOpticalFibersSect); - // The low voltage cables inside the tray: a Xtru - TGeoXtru *lowCables = new TGeoXtru(2); - - xprof[0] = sideCMidFace->GetX(5); - yprof[0] = sideCMidFace->GetY(5); - xprof[1] = sideCMidFace->GetX(4); - yprof[1] = sideCMidFace->GetY(4); - xprof[2] = sideCMidFace->GetX(3); - yprof[2] = sideCMidFace->GetY(3); - xprof[3] = xprof[2] - kLowVoltageCableSect*SinD(kTrayCFoldAngle); - yprof[3] = yprof[2] + kLowVoltageCableSect*CosD(kTrayCFoldAngle); - InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], - kLowVoltageCableSect , xprof[4], yprof[4]); - xprof[5] = 0.; - yprof[5] = yprof[0] + kLowVoltageCableSect; - - lowCables->DefinePolygon(6, xprof, yprof); - lowCables->DefineSection(0, 0); - lowCables->DefineSection(1, kLowVoltageCableSect); + // The 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 *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$"); + TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$"); + TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$"); + TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$"); - TGeoVolume *traySideCHorFace = new TGeoVolume("ITSsuppSPDTraySideCHor", - sideCHorFace, medAl); + TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal", + trayIntern, medAl); - traySideCHorFace->SetVisibility(kTRUE); - traySideCHorFace->SetLineColor(6); // Purple - traySideCHorFace->SetLineWidth(1); - traySideCHorFace->SetFillColor(traySideCHorFace->GetLineColor()); - traySideCHorFace->SetFillStyle(4000); // 0% transparent + traySideCIntern->SetVisibility(kTRUE); + traySideCIntern->SetLineColor(6); // Purple + traySideCIntern->SetLineWidth(1); + traySideCIntern->SetFillColor(traySideCIntern->GetLineColor()); + traySideCIntern->SetFillStyle(4000); // 0% transparent TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid", sideCMidFace, medAl); @@ -3983,15 +5313,6 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor()); traySideCLongCover->SetFillStyle(4000); // 0% transparent - TGeoVolume *traySideCIntWall = new TGeoVolume("ITSsuppSPDTraySideCWall", - intWall, medAl); - - traySideCIntWall->SetVisibility(kTRUE); - traySideCIntWall->SetLineColor(6); // Purple - traySideCIntWall->SetLineWidth(1); - traySideCIntWall->SetFillColor(traySideCIntWall->GetLineColor()); - traySideCIntWall->SetFillStyle(4000); // 0% transparent - TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube", horTube, medIn); @@ -4001,6 +5322,15 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, 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); @@ -4010,6 +5340,33 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, 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); @@ -4019,18 +5376,63 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor()); traySideCOptFibs->SetFillStyle(4000); // 0% transparent - TGeoVolume *traySideCLowCabs = new TGeoVolume("ITSsuppSPDTraySideCLowCabs", - lowCables, medLVC); + TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu", + lowCablesCu, medCu); + + traySideCLowCabsCu->SetVisibility(kTRUE); + traySideCLowCabsCu->SetLineColor(kRed); // Red + traySideCLowCabsCu->SetLineWidth(1); + traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor()); + traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR", + lowCablesPUR, medPUR); + + traySideCLowCabsPUR->SetVisibility(kTRUE); + traySideCLowCabsPUR->SetLineColor(kBlack); // Black + traySideCLowCabsPUR->SetLineWidth(1); + traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor()); + traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu", + hiCablesCu, medCu); - traySideCLowCabs->SetVisibility(kTRUE); - traySideCLowCabs->SetLineColor(kRed); // Red - traySideCLowCabs->SetLineWidth(1); - traySideCLowCabs->SetFillColor(traySideCLowCabs->GetLineColor()); - traySideCLowCabs->SetFillStyle(4000); // 0% transparent + 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(traySideCHorFace,1,0); + cableTrayC->AddNode(traySideCIntern,1,0); cableTrayC->AddNode(traySideCMidFace,1,0); @@ -4048,7 +5450,9 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, cableTrayC->AddNode(traySideCLongCover,1,0); - cableTrayC->AddNode(traySideCIntWall,1,0); + traySideCHorTube->AddNode(traySideCHorFreon, 1, 0); + traySideCIncTube->AddNode(traySideCIncFreon, 1, 0); + traySideCOutTube->AddNode(traySideCOutFreon, 1, 0); xloc = horTube->GetDz(); yloc = sideCMidFace->GetY(5) + horTube->GetRmax(); @@ -4063,13 +5467,34 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, new TGeoCombiTrans( xloc, yloc, 0, new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.))); + xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax(); + yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) - + 2*outTube->GetRmax(); + cableTrayC->AddNode(traySideCOutTube, 1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-70.,-90.,90.))); + zloc = horTube->GetRmax(); cableTrayC->AddNode(traySideCOptFibs, 1, new TGeoTranslation( 0, 0, zloc)); - zloc = kLowVoltageCableSect + horTube->GetRmax(); - cableTrayC->AddNode(traySideCLowCabs, 1, + zloc = kLowVoltCableSectCu + horTube->GetRmax(); + cableTrayC->AddNode(traySideCLowCabsCu, 1, + new TGeoTranslation( 0, 0,-zloc)); + cableTrayC->AddNode(traySideCLowCabsPUR, 1, + new TGeoTranslation( 0, 0,-zloc)); + + zloc = 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 @@ -4095,7 +5520,7 @@ void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SDD cable trays which are outside the ITS support cones // but still inside the TPC on Side A @@ -4110,6 +5535,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, // 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 @@ -4120,12 +5546,14 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, const Double_t kTrayARTrans = 408.35 *fgkmm; const Double_t kTrayAZTrans = 1011.00 *fgkmm; const Double_t kTrayAZToSupportRing = 435.00 *fgkmm; - const Double_t kExternTrayZTrans = 853.00 *fgkmm; + const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed + const Double_t kExternTrayZTrans = 823.00 *fgkmm; const Double_t kExternCoverYTrans = 2.00 *fgkmm; const Double_t kTrayAZRot = (180-169.5);// Degrees const Double_t kTrayAFirstRotAng = 22.00; // Degrees const Double_t kTrayASecondRotAng = 15.00; // Degrees + const Double_t kForwardTrayThick = 2.00 *fgkmm; const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed @@ -4142,10 +5570,63 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, const Int_t kForwardTrayNpoints = 8; + // Dimensions and positions of the Cable Tray elements + const Double_t kSideACoolManifWide = 8.23 *fgkcm; + const Double_t kSideACoolManifHigh = 8.06 *fgkcm; + const Double_t kSideACoolManifLen = 3.90 *fgkcm; + const Double_t kSideACoolManifPOMFrac = 0.0054; + const Double_t kSideACoolManifSteelFrac= 0.8850; + const Double_t kSideACoolManifWaterFrac= 0.0913; + const Double_t kSideACoolManifAlFrac = 0.0183; + + const Double_t kSideACoolTubesWide = 9.07 *fgkcm; + const Double_t kSideACoolTubesHigh = 1.88 *fgkcm; + const Double_t kSideACoolTubesTrans = 0.88 *fgkcm; + const Double_t kSideACoolTubesPURFrac = 0.5897; + const Double_t kSideACoolTubesWaterFrac= 0.4101; + const Double_t kSideACoolTubesAirFrac = 0.0002; + + const Double_t kSideAOptConnWide = 0.90 *fgkcm; + const Double_t kSideAOptConnLen = 1.37 *fgkcm; + const Double_t kSideAOptConnPBTFrac = 0.5010; + const Double_t kSideAOptConnSteelFrac = 0.1784; + const Double_t kSideAOptConnAlFrac = 0.3206; + + const Double_t kSideAOptFibsWide = 0.71 *fgkcm; + const Double_t kSideAOptFibsHigh = 3.20 *fgkcm; + + const Double_t kSideAInputCablesWide = 12.50 *fgkcm; + const Double_t kSideAInputCablesHigh = 1.24 *fgkcm; + const Double_t kSideAInputCablesLen = 25.20 *fgkcm; + const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm; + const Double_t kSideAInputCablesCu = 0.7404; + const Double_t kSideAInputCablesPlast = 0.1269; + const Double_t kSideAInputCablesAl = 0.0057; + const Double_t kSideAInputCablesKapton = 0.0172; + const Double_t kSideAInputCablesPOLYAX = 0.1098; + + const Double_t kSideAOutputCablesWide = 8.30 *fgkcm; + const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm; + const Double_t kSideAOutputCablesCu = 0.6783; + const Double_t kSideAOutputCablesPlast = 0.1605; + const Double_t kSideAOutputCablesAl = 0.0078; + const Double_t kSideAOutputCablesKapton= 0.0232; + const Double_t kSideAOutputCablesPOLYAX= 0.1302; + + const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm; + const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm; + const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm; + const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm; + const Double_t kSideAPCBBoardsCu = 0.3864; + const Double_t kSideAPCBBoardsEpoxy = 0.1486; + const Double_t kSideAPCBBoardsPlast = 0.0578; + const Double_t kSideAPCBBoardsSteel = 0.1521; + const Double_t kSideAPCBBoardsPPS = 0.2551; + // Local variables Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints]; - Double_t xloc, yloc, zloc, alpharot; + Double_t xloc, yloc, zloc, alpharot, height; // The whole tray as an assembly @@ -4155,7 +5636,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, // First create all needed shapes // The forward tray is very complex and deserves a dedicated method - TGeoVolumeAssembly *forwardTray = CreateSDDForwardTraySideA(mgr); + CreateSDDForwardTraySideA(cableTrayA,mgr); // The forward cover: a Xtru TGeoXtru *forwardCover = new TGeoXtru(2); @@ -4187,10 +5668,289 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, // 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 *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); @@ -4219,66 +5979,381 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, externTrayCover->SetFillColor(externTrayCover->GetLineColor()); externTrayCover->SetFillStyle(4000); // 0% transparent + TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM", + coolManifPOM, medPOM); + + pomCoolManif->SetVisibility(kTRUE); + pomCoolManif->SetLineColor(kRed); // Red + pomCoolManif->SetLineWidth(1); + pomCoolManif->SetFillColor(pomCoolManif->GetLineColor()); + pomCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel", + coolManifSteel, medSteel); + + steelCoolManif->SetVisibility(kTRUE); + steelCoolManif->SetLineColor(kBlue); // Blue + steelCoolManif->SetLineWidth(1); + steelCoolManif->SetFillColor(steelCoolManif->GetLineColor()); + steelCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater", + coolManifWater, medWater); + + waterCoolManif->SetVisibility(kTRUE); + waterCoolManif->SetLineColor(33); // Light Blue + waterCoolManif->SetLineWidth(1); + waterCoolManif->SetFillColor(waterCoolManif->GetLineColor()); + waterCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl", + coolManifAl, medAl); + + alCoolManif->SetVisibility(kTRUE); + alCoolManif->SetLineColor(6); // Purple + alCoolManif->SetLineWidth(1); + alCoolManif->SetFillColor(alCoolManif->GetLineColor()); + alCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR", + coolTubesPUR, medPUR); + + purCoolTubes->SetVisibility(kTRUE); + purCoolTubes->SetLineColor(kRed); // Red + purCoolTubes->SetLineWidth(1); + purCoolTubes->SetFillColor(purCoolTubes->GetLineColor()); + purCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater", + coolTubesWater, medWater); + + waterCoolTubes->SetVisibility(kTRUE); + waterCoolTubes->SetLineColor(33); // Light Blue + waterCoolTubes->SetLineWidth(1); + waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor()); + waterCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir", + coolTubesAir, medAir); + + airCoolTubes->SetVisibility(kTRUE); + airCoolTubes->SetLineColor(41); + airCoolTubes->SetLineWidth(1); + airCoolTubes->SetFillColor(airCoolTubes->GetLineColor()); + airCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT", + optConnPBT, medPBT); + + pbtOptConn->SetVisibility(kTRUE); + pbtOptConn->SetLineColor(kRed); // Red + pbtOptConn->SetLineWidth(1); + pbtOptConn->SetFillColor(pbtOptConn->GetLineColor()); + pbtOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel", + optConnSteel, medSteel); + + steelOptConn->SetVisibility(kTRUE); + steelOptConn->SetLineColor(kBlue); // Blue + steelOptConn->SetLineWidth(1); + steelOptConn->SetFillColor(steelOptConn->GetLineColor()); + steelOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl", + optConnAl, medAl); + + alOptConn->SetVisibility(kTRUE); + alOptConn->SetLineColor(6); // Purple + alOptConn->SetLineWidth(1); + alOptConn->SetFillColor(alOptConn->GetLineColor()); + alOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs", + opticalFibs, medOptFib); + + optFibs->SetVisibility(kTRUE); + optFibs->SetLineColor(kOrange+2); // Orange + optFibs->SetLineWidth(1); + optFibs->SetFillColor(optFibs->GetLineColor()); + optFibs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu", + inputCabsCu, medCu); + + cuInputCabs->SetVisibility(kTRUE); + cuInputCabs->SetLineColor(kBlack); // Black + cuInputCabs->SetLineWidth(1); + cuInputCabs->SetFillColor(cuInputCabs->GetLineColor()); + cuInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast", + inputCabsPlast, medPUR); + + plastInputCabs->SetVisibility(kTRUE); + plastInputCabs->SetLineColor(kRed); // Red + plastInputCabs->SetLineWidth(1); + plastInputCabs->SetFillColor(plastInputCabs->GetLineColor()); + plastInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl", + inputCabsAl, medAl); + + alInputCabs->SetVisibility(kTRUE); + alInputCabs->SetLineColor(6); // Purple + alInputCabs->SetLineWidth(1); + alInputCabs->SetFillColor(alInputCabs->GetLineColor()); + alInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton", + inputCabsKapton, medKapton); + + kaptonInputCabs->SetVisibility(kTRUE); + kaptonInputCabs->SetLineColor(14); // + kaptonInputCabs->SetLineWidth(1); + kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor()); + kaptonInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX", + inputCabsPOLYAX, medPOLYAX); + + polyaxInputCabs->SetVisibility(kTRUE); + polyaxInputCabs->SetLineColor(34); // + polyaxInputCabs->SetLineWidth(1); + polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor()); + polyaxInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu", + outputCabsCu, medCu); + + cuOutputCabs->SetVisibility(kTRUE); + cuOutputCabs->SetLineColor(kBlack); // Black + cuOutputCabs->SetLineWidth(1); + cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor()); + cuOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast", + outputCabsPlast, medPUR); + + plastOutputCabs->SetVisibility(kTRUE); + plastOutputCabs->SetLineColor(kRed); // Red + plastOutputCabs->SetLineWidth(1); + plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor()); + plastOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl", + outputCabsAl, medAl); + + alOutputCabs->SetVisibility(kTRUE); + alOutputCabs->SetLineColor(6); // Purple + alOutputCabs->SetLineWidth(1); + alOutputCabs->SetFillColor(alOutputCabs->GetLineColor()); + alOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton", + outputCabsKapton, medKapton); + + kaptonOutputCabs->SetVisibility(kTRUE); + kaptonOutputCabs->SetLineColor(14); // + kaptonOutputCabs->SetLineWidth(1); + kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor()); + kaptonOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX", + outputCabsPOLYAX, medPOLYAX); + + polyaxOutputCabs->SetVisibility(kTRUE); + polyaxOutputCabs->SetLineColor(34); // + polyaxOutputCabs->SetLineWidth(1); + polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor()); + polyaxOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu", + pcbBoardsCu, medCu); + + cuPCBBoards->SetVisibility(kTRUE); + cuPCBBoards->SetLineColor(kBlack); // Black + cuPCBBoards->SetLineWidth(1); + cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor()); + cuPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy", + pcbBoardsEpoxy, medEpoxy); + + epoxyPCBBoards->SetVisibility(kTRUE); + epoxyPCBBoards->SetLineColor(22); // + epoxyPCBBoards->SetLineWidth(1); + epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor()); + epoxyPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast", + pcbBoardsPlast, medPUR); + + plastPCBBoards->SetVisibility(kTRUE); + plastPCBBoards->SetLineColor(kRed); // Red + plastPCBBoards->SetLineWidth(1); + plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor()); + plastPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel", + pcbBoardsSteel, medSteel); + + steelPCBBoards->SetVisibility(kTRUE); + steelPCBBoards->SetLineColor(kBlue); // Blue + steelPCBBoards->SetLineWidth(1); + steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor()); + steelPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS", + pcbBoardsPPS, medPPS); + + ppsPCBBoards->SetVisibility(kTRUE); + ppsPCBBoards->SetLineColor(kGreen); // Green + ppsPCBBoards->SetLineWidth(1); + ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor()); + ppsPCBBoards->SetFillStyle(4000); // 0% transparent + // Now build up the tray - yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) + - kExternTrayTotalHeight + - kExternCoverSideThick - kForwardTrayTailHeight; - zloc = kTrayAZToSupportRing - kForwardCoverLength; + yloc = kForwardTrayTotalHeight - forwardCover->GetY(3); + zloc = kForwardTrayUpperLength - kForwardCoverLength; cableTrayA->AddNode(forwardTrayCover, 1, new TGeoTranslation( 0, yloc, zloc) ); Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick - kExternCoverYTrans; - yloc = totalhi*(1 - CosD(kTrayAZRot)); + yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans - + kExternTrayTotalHeight*CosD(kTrayAZRot); zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot); cableTrayA->AddNode(externalTraySDD, 1, new TGeoCombiTrans( 0, yloc, zloc, new TGeoRotation("", 0,-kTrayAZRot, 0) ) ); - yloc = kExternTrayTotalHeight - kExternCoverYTrans; - zloc = kExternTrayZTrans - yloc*SinD(kTrayAZRot); - yloc *= CosD(kTrayAZRot); - zloc += totalhi*SinD(kTrayAZRot); - yloc += totalhi*(1 - CosD(kTrayAZRot)); + yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans - + kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01; + zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot); cableTrayA->AddNode(externTrayCover,1, new TGeoCombiTrans( 0, yloc, zloc, new TGeoRotation("", 0,-kTrayAZRot, 0) ) ); + yloc = kForwardTrayThick + coolManifPOM->GetDY(); + zloc = coolManifPOM->GetDZ(); + cableTrayA->AddNode(pomCoolManif, 1, + new TGeoTranslation( 0, yloc, zloc) ); - // Finally put everything in the mother volume - alpharot = -kTrayAFirstRotAng; - xloc = kTrayARTrans*SinD(alpharot); - yloc = kTrayARTrans*CosD(alpharot); - zloc = kTrayAZTrans; - moth->AddNode(cableTrayA,1, - new TGeoCombiTrans( xloc, yloc, zloc, - new TGeoRotation("",-alpharot,0,0) ) ); + yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY(); + cableTrayA->AddNode(steelCoolManif, 1, + new TGeoTranslation( 0, yloc, zloc) ); - alpharot += 180; - xloc = kTrayARTrans*SinD(alpharot); - yloc = kTrayARTrans*CosD(alpharot); - moth->AddNode(cableTrayA,2, - new TGeoCombiTrans( xloc, yloc, zloc, - new TGeoRotation("",-alpharot,0,0) ) ); + yloc += coolManifSteel->GetDY() + coolManifWater->GetDY(); + cableTrayA->AddNode(waterCoolManif, 1, + new TGeoTranslation( 0, yloc, zloc) ); - alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng; - xloc = kTrayARTrans*SinD(alpharot); - yloc = kTrayARTrans*CosD(alpharot); - moth->AddNode(cableTrayA,3, - new TGeoCombiTrans( xloc, yloc, zloc, - new TGeoRotation("",-alpharot,0,0) ) ); + yloc += coolManifWater->GetDY() + coolManifAl->GetDY(); + cableTrayA->AddNode(alCoolManif, 1, + new TGeoTranslation( 0, yloc, zloc) ); - alpharot += 180; - xloc = kTrayARTrans*SinD(alpharot); - yloc = kTrayARTrans*CosD(alpharot); - moth->AddNode(cableTrayA,4, - new TGeoCombiTrans( xloc, yloc, zloc, - new TGeoRotation("",-alpharot,0,0) ) ); + 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) ); - // To avoid putting an assembly inside another assembly, - // the forwardTray is put directly in the mother volume + 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; @@ -4288,28 +6363,28 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, yloc = rforw*CosD(alpharot); zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength; - moth->AddNode(forwardTray,1, + moth->AddNode(cableTrayA,1, new TGeoCombiTrans( xloc, yloc, zloc, new TGeoRotation("",-alpharot,0,0) ) ); alpharot += 180; xloc = rforw*SinD(alpharot); yloc = rforw*CosD(alpharot); - moth->AddNode(forwardTray,2, + moth->AddNode(cableTrayA,2, new TGeoCombiTrans( xloc, yloc, zloc, new TGeoRotation("",-alpharot,0,0) ) ); alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng; xloc = rforw*SinD(alpharot); yloc = rforw*CosD(alpharot); - moth->AddNode(forwardTray,3, + moth->AddNode(cableTrayA,3, new TGeoCombiTrans( xloc, yloc, zloc, new TGeoRotation("",-alpharot,0,0) ) ); alpharot += 180; xloc = rforw*SinD(alpharot); yloc = rforw*CosD(alpharot); - moth->AddNode(forwardTray,4, + moth->AddNode(cableTrayA,4, new TGeoCombiTrans( xloc, yloc, zloc, new TGeoRotation("",-alpharot,0,0) ) ); @@ -4319,7 +6394,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SDD cable trays which are outside the ITS support cones // but still inside the TPC on Side C @@ -4338,11 +6413,71 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth, // information given by F.Tosello // - // Dimensions and positions of the C-Side Cable Tray elements + // Dimensions and positions of the C-Side Cable Tray + // (Change accordingly to CreateSDDSSDTraysSideC !) const Int_t kNumTraySideC = 4; + const Double_t kSideCHalfThick = 0.100 *fgkcm; + const Double_t kSideCLength1 = 172.800 *fgkcm; + const Double_t kSideCLength2 = 189.300 *fgkcm; + const Double_t kBarCoolRmax = 0.4 *fgkcm; + const Double_t kXShiftBarCool = 13.00 *fgkcm; + const Double_t kSideCFoldAngle = 5.00 *fgkDegree; + // Dimensions and positions of the Cable Tray elements + const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm; + const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm; + const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm; + const Double_t kSideCCoolManifPOMFrac = 0.0051; + const Double_t kSideCCoolManifSteelFrac= 0.8502; + const Double_t kSideCCoolManifWaterFrac= 0.0868; + const Double_t kSideCCoolManifAlFrac = 0.0579; + + const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm; + const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm; + const Double_t kSideCCoolTubesPURFrac = 0.5884; + const Double_t kSideCCoolTubesWaterFrac= 0.4114; + const Double_t kSideCCoolTubesAirFrac = 0.0002; + + const Double_t kSideCOptConnHalfX = 0.90 *fgkcm; + const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm; + const Double_t kSideCOptConnPBTFrac = 0.6798; + const Double_t kSideCOptConnSteelFrac = 0.2421; + const Double_t kSideCOptConnAlFrac = 0.0781; + + const Double_t kSideCOptFibsWide = 0.71 *fgkcm; + const Double_t kSideCOptFibsHigh = 3.20 *fgkcm; + const Double_t kSideCOptFibsTrans = 0.20 *fgkcm; + + const Double_t kSideCInputCablesLen = 31.45 *fgkcm; + const Double_t kSideCInputCablesWide = 12.50 *fgkcm; + const Double_t kSideCInputCablesHigh = 0.95 *fgkcm; + const Double_t kSideCInputCablesTrans = 1.15 *fgkcm; + const Double_t kSideCInputCablesCu = 0.7405; + const Double_t kSideCInputCablesPlast = 0.1268; + const Double_t kSideCInputCablesAl = 0.0057; + const Double_t kSideCInputCablesKapton = 0.0172; + const Double_t kSideCInputCablesPOLYAX = 0.1098; + + const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm; + const Double_t kSideCOutputCablesWide = 8.50 *fgkcm; + const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm; + const Double_t kSideCOutputCablesCu = 0.6775; + const Double_t kSideCOutputCablesPlast = 0.1613; + const Double_t kSideCOutputCablesAl = 0.0078; + const Double_t kSideCOutputCablesKapton= 0.0234; + const Double_t kSideCOutputCablesPOLYAX= 0.1300; + + const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm; + const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm; + const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm; + const Double_t kSideCPCBBoardsCu = 0.3864; + const Double_t kSideCPCBBoardsEpoxy = 0.1491; + const Double_t kSideCPCBBoardsPlast = 0.0579; + const Double_t kSideCPCBBoardsSteel = 0.1517; + const Double_t kSideCPCBBoardsPPS = 0.2549; + // Overall position and rotation of the C-Side Cable Trays const Double_t kTraySideCRPos = 45.30 *fgkcm; const Double_t kTraySideCZPos = -102.40 *fgkcm; @@ -4351,18 +6486,629 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth, // Local variables -// Double_t xprof[12], yprof[12]; - Double_t xloc, yloc, alpharot, alphafold; + Double_t xprof[6], yprof[6]; + Double_t height, xloc, yloc, zloc, alpharot, alphafold; // The assembly holding the metallic structure - TGeoVolumeAssembly *trayStructure = - CreateSDDSSDTraysSideC("ITSsupportSDDTrayC"); + TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC"); + + // Now the volumes inside it + // The cooling manifold: four boxes + // (X and Z are inverted on tray reference system) + TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ, + kSideCCoolManifPOMFrac*kSideCCoolManifHalfY, + kSideCCoolManifHalfX); + + TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ, + kSideCCoolManifSteelFrac*kSideCCoolManifHalfY, + kSideCCoolManifHalfX); + + TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ, + kSideCCoolManifWaterFrac*kSideCCoolManifHalfY, + kSideCCoolManifHalfX); + + TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ, + kSideCCoolManifAlFrac*kSideCCoolManifHalfY, + kSideCCoolManifHalfX); + + // The cooling tubes: three Xtru's + alpharot = kSideCFoldAngle*TMath::DegToRad(); + + TGeoXtru *coolTubesPUR = new TGeoXtru(2); + + height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac; + + xprof[0] = 2*kSideCCoolManifHalfZ; + yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans; + xprof[1] = kSideCLength1; + yprof[1] = yprof[0]; + xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot); + yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + coolTubesPUR->DefinePolygon(6, xprof, yprof); + coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX); + coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX); + + TGeoXtru *coolTubesWater = new TGeoXtru(2); + + height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac; + + xprof[0] = coolTubesPUR->GetX(5); + yprof[0] = coolTubesPUR->GetY(5); + xprof[1] = coolTubesPUR->GetX(4); + yprof[1] = coolTubesPUR->GetY(4); + xprof[2] = coolTubesPUR->GetX(3); + yprof[2] = coolTubesPUR->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + coolTubesWater->DefinePolygon(6, xprof, yprof); + coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX); + coolTubesWater->DefineSection(1, kSideCCoolManifHalfX); + + TGeoXtru *coolTubesAir = new TGeoXtru(2); + + height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac; + + xprof[0] = coolTubesWater->GetX(5); + yprof[0] = coolTubesWater->GetY(5); + xprof[1] = coolTubesWater->GetX(4); + yprof[1] = coolTubesWater->GetY(4); + xprof[2] = coolTubesWater->GetX(3); + yprof[2] = coolTubesWater->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + coolTubesAir->DefinePolygon(6, xprof, yprof); + coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX); + coolTubesAir->DefineSection(1, kSideCCoolManifHalfX); + + // The optical fiber connectors: three boxes + // (X and Z are inverted on tray reference system) + TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ, + kSideCOptConnPBTFrac*kSideCCoolManifHalfY, + kSideCOptConnHalfX); + + TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ, + kSideCOptConnSteelFrac*kSideCCoolManifHalfY, + kSideCOptConnHalfX); + + TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ, + kSideCOptConnAlFrac*kSideCCoolManifHalfY, + kSideCOptConnHalfX); + + // The optical fibers: a Xtru + TGeoXtru *opticalFibs = new TGeoXtru(2); + + xprof[0] = 2*kSideCOptConnHalfZ; + yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans; + xprof[1] = kSideCLength1; + yprof[1] = yprof[0]; + xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot); + yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot); + xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot); + yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kSideCOptFibsHigh, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kSideCOptFibsHigh; + + opticalFibs->DefinePolygon(6, xprof, yprof); + opticalFibs->DefineSection(0,-kSideCOptFibsWide/2); + opticalFibs->DefineSection(1, kSideCOptFibsWide/2); + + // The input cables: five boxes + // (X and Z are inverted on tray reference system) + TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2, + kSideCInputCablesCu*kSideCInputCablesHigh/2, + kSideCInputCablesWide/2); + + TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2, + kSideCInputCablesPlast*kSideCInputCablesHigh/2, + kSideCInputCablesWide/2); + + TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2, + kSideCInputCablesAl*kSideCInputCablesHigh/2, + kSideCInputCablesWide/2); + + TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2, + kSideCInputCablesKapton*kSideCInputCablesHigh/2, + kSideCInputCablesWide/2); + + TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2, + kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2, + kSideCInputCablesWide/2); + + // The output cables: five Xtru + TGeoXtru *outputCabsCu = new TGeoXtru(2); + + height = kSideCOutputCablesCu*kSideCOutputCablesHigh; + + xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0; + yprof[0] = coolTubesAir->GetY(5); + xprof[1] = coolTubesAir->GetX(4); + yprof[1] = coolTubesAir->GetY(4); + xprof[2] = coolTubesAir->GetX(3); + yprof[2] = coolTubesAir->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + outputCabsCu->DefinePolygon(6, xprof, yprof); + outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2); + outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2); + + TGeoXtru *outputCabsPlast = new TGeoXtru(2); + + height = kSideCOutputCablesPlast*kSideCOutputCablesHigh; + + xprof[0] = outputCabsCu->GetX(5); + yprof[0] = outputCabsCu->GetY(5); + xprof[1] = outputCabsCu->GetX(4); + yprof[1] = outputCabsCu->GetY(4); + xprof[2] = outputCabsCu->GetX(3); + yprof[2] = outputCabsCu->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + outputCabsPlast->DefinePolygon(6, xprof, yprof); + outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2); + outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2); + + TGeoXtru *outputCabsAl = new TGeoXtru(2); + + height = kSideCOutputCablesAl*kSideCOutputCablesHigh; + + xprof[0] = outputCabsPlast->GetX(5); + yprof[0] = outputCabsPlast->GetY(5); + xprof[1] = outputCabsPlast->GetX(4); + yprof[1] = outputCabsPlast->GetY(4); + xprof[2] = outputCabsPlast->GetX(3); + yprof[2] = outputCabsPlast->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + outputCabsAl->DefinePolygon(6, xprof, yprof); + outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2); + outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2); + + TGeoXtru *outputCabsKapton = new TGeoXtru(2); + + height = kSideCOutputCablesKapton*kSideCOutputCablesHigh; + + xprof[0] = outputCabsAl->GetX(5); + yprof[0] = outputCabsAl->GetY(5); + xprof[1] = outputCabsAl->GetX(4); + yprof[1] = outputCabsAl->GetY(4); + xprof[2] = outputCabsAl->GetX(3); + yprof[2] = outputCabsAl->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + outputCabsKapton->DefinePolygon(6, xprof, yprof); + outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2); + outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2); + + TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2); + + height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh; + + xprof[0] = outputCabsKapton->GetX(5); + yprof[0] = outputCabsKapton->GetY(5); + xprof[1] = outputCabsKapton->GetX(4); + yprof[1] = outputCabsKapton->GetY(4); + xprof[2] = outputCabsKapton->GetX(3); + yprof[2] = outputCabsKapton->GetY(3); + xprof[3] = xprof[2] - height*TMath::Sin(alpharot); + yprof[3] = yprof[2] + height*TMath::Cos(alpharot); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + height, xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + height; + + outputCabsPOLYAX->DefinePolygon(6, xprof, yprof); + outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2); + outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2); + + // The PCB boards: five boxes + // (X and Z are inverted on tray reference system) + TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ, + kSideCPCBBoardsCu*kSideCPCBBoardsHalfY, + kSideCPCBBoardsHalfX); + + TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ, + kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY, + kSideCPCBBoardsHalfX); + + TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ, + kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY, + kSideCPCBBoardsHalfX); + + TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ, + kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY, + kSideCPCBBoardsHalfX); + + TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ, + kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY, + kSideCPCBBoardsHalfX); // We have all shapes: now create the real volumes - TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); - if (0==1) medAl->Print(); + TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$"); + TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$"); + TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$"); + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$"); + TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$"); + TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$"); + TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$"); + TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$"); + TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$"); + TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$"); + TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$"); + TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$"); + + TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM", + coolManifPOM, medPOM); + + pomCoolManif->SetVisibility(kTRUE); + pomCoolManif->SetLineColor(kRed); // Red + pomCoolManif->SetLineWidth(1); + pomCoolManif->SetFillColor(pomCoolManif->GetLineColor()); + pomCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel", + coolManifSteel, medSteel); + + steelCoolManif->SetVisibility(kTRUE); + steelCoolManif->SetLineColor(kBlue); // Blue + steelCoolManif->SetLineWidth(1); + steelCoolManif->SetFillColor(steelCoolManif->GetLineColor()); + steelCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater", + coolManifWater, medWater); + + waterCoolManif->SetVisibility(kTRUE); + waterCoolManif->SetLineColor(33); // Light Blue + waterCoolManif->SetLineWidth(1); + waterCoolManif->SetFillColor(waterCoolManif->GetLineColor()); + waterCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl", + coolManifAl, medAl); + + alCoolManif->SetVisibility(kTRUE); + alCoolManif->SetLineColor(6); // Purple + alCoolManif->SetLineWidth(1); + alCoolManif->SetFillColor(alCoolManif->GetLineColor()); + alCoolManif->SetFillStyle(4000); // 0% transparent + + TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR", + coolTubesPUR, medPUR); + + purCoolTubes->SetVisibility(kTRUE); + purCoolTubes->SetLineColor(kRed); // Red + purCoolTubes->SetLineWidth(1); + purCoolTubes->SetFillColor(purCoolTubes->GetLineColor()); + purCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater", + coolTubesWater, medWater); + + waterCoolTubes->SetVisibility(kTRUE); + waterCoolTubes->SetLineColor(33); // Light Blue + waterCoolTubes->SetLineWidth(1); + waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor()); + waterCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir", + coolTubesAir, medAir); + + airCoolTubes->SetVisibility(kTRUE); + airCoolTubes->SetLineColor(41); + airCoolTubes->SetLineWidth(1); + airCoolTubes->SetFillColor(airCoolTubes->GetLineColor()); + airCoolTubes->SetFillStyle(4000); // 0% transparent + + TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT", + optConnPBT, medPBT); + + pbtOptConn->SetVisibility(kTRUE); + pbtOptConn->SetLineColor(kRed); // Red + pbtOptConn->SetLineWidth(1); + pbtOptConn->SetFillColor(pbtOptConn->GetLineColor()); + pbtOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel", + optConnSteel, medSteel); + + steelOptConn->SetVisibility(kTRUE); + steelOptConn->SetLineColor(kBlue); // Blue + steelOptConn->SetLineWidth(1); + steelOptConn->SetFillColor(steelOptConn->GetLineColor()); + steelOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl", + optConnAl, medAl); + + alOptConn->SetVisibility(kTRUE); + alOptConn->SetLineColor(6); // Purple + alOptConn->SetLineWidth(1); + alOptConn->SetFillColor(alOptConn->GetLineColor()); + alOptConn->SetFillStyle(4000); // 0% transparent + + TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs", + opticalFibs, medOptFib); + + optFibs->SetVisibility(kTRUE); + optFibs->SetLineColor(kOrange+2); // Orange + optFibs->SetLineWidth(1); + optFibs->SetFillColor(optFibs->GetLineColor()); + optFibs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu", + inputCabsCu, medCu); + + cuInputCabs->SetVisibility(kTRUE); + cuInputCabs->SetLineColor(kBlack); // Black + cuInputCabs->SetLineWidth(1); + cuInputCabs->SetFillColor(cuInputCabs->GetLineColor()); + cuInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast", + inputCabsPlast, medPUR); + + plastInputCabs->SetVisibility(kTRUE); + plastInputCabs->SetLineColor(kRed); // Red + plastInputCabs->SetLineWidth(1); + plastInputCabs->SetFillColor(plastInputCabs->GetLineColor()); + plastInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl", + inputCabsAl, medAl); + + alInputCabs->SetVisibility(kTRUE); + alInputCabs->SetLineColor(6); // Purple + alInputCabs->SetLineWidth(1); + alInputCabs->SetFillColor(alInputCabs->GetLineColor()); + alInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton", + inputCabsKapton, medKapton); + + kaptonInputCabs->SetVisibility(kTRUE); + kaptonInputCabs->SetLineColor(14); // + kaptonInputCabs->SetLineWidth(1); + kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor()); + kaptonInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX", + inputCabsPOLYAX, medPOLYAX); + + polyaxInputCabs->SetVisibility(kTRUE); + polyaxInputCabs->SetLineColor(34); // + polyaxInputCabs->SetLineWidth(1); + polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor()); + polyaxInputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu", + outputCabsCu, medCu); + + cuOutputCabs->SetVisibility(kTRUE); + cuOutputCabs->SetLineColor(kBlack); // Black + cuOutputCabs->SetLineWidth(1); + cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor()); + cuOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast", + outputCabsPlast, medPUR); + + plastOutputCabs->SetVisibility(kTRUE); + plastOutputCabs->SetLineColor(kRed); // Red + plastOutputCabs->SetLineWidth(1); + plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor()); + plastOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl", + outputCabsAl, medAl); + + alOutputCabs->SetVisibility(kTRUE); + alOutputCabs->SetLineColor(6); // Purple + alOutputCabs->SetLineWidth(1); + alOutputCabs->SetFillColor(alOutputCabs->GetLineColor()); + alOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton", + outputCabsKapton, medKapton); + + kaptonOutputCabs->SetVisibility(kTRUE); + kaptonOutputCabs->SetLineColor(14); // + kaptonOutputCabs->SetLineWidth(1); + kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor()); + kaptonOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX", + outputCabsPOLYAX, medPOLYAX); + + polyaxOutputCabs->SetVisibility(kTRUE); + polyaxOutputCabs->SetLineColor(34); // + polyaxOutputCabs->SetLineWidth(1); + polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor()); + polyaxOutputCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu", + pcbBoardsCu, medCu); + + cuPCBBoards->SetVisibility(kTRUE); + cuPCBBoards->SetLineColor(kBlack); // Black + cuPCBBoards->SetLineWidth(1); + cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor()); + cuPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy", + pcbBoardsEpoxy, medEpoxy); + + epoxyPCBBoards->SetVisibility(kTRUE); + epoxyPCBBoards->SetLineColor(22); // + epoxyPCBBoards->SetLineWidth(1); + epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor()); + epoxyPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast", + pcbBoardsPlast, medPUR); + + plastPCBBoards->SetVisibility(kTRUE); + plastPCBBoards->SetLineColor(kRed); // Red + plastPCBBoards->SetLineWidth(1); + plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor()); + plastPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel", + pcbBoardsSteel, medSteel); + + steelPCBBoards->SetVisibility(kTRUE); + steelPCBBoards->SetLineColor(kBlue); // Blue + steelPCBBoards->SetLineWidth(1); + steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor()); + steelPCBBoards->SetFillStyle(4000); // 0% transparent + + TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS", + pcbBoardsPPS, medPPS); + + ppsPCBBoards->SetVisibility(kTRUE); + ppsPCBBoards->SetLineColor(kGreen); // Green + ppsPCBBoards->SetLineWidth(1); + ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor()); + ppsPCBBoards->SetFillStyle(4000); // 0% transparent + + + // Now fill the tray + xloc = coolManifPOM->GetDX(); + yloc = 2*kSideCHalfThick + coolManifPOM->GetDY(); + trayStructure->AddNode(pomCoolManif, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY(); + trayStructure->AddNode(steelCoolManif, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += coolManifSteel->GetDY() + coolManifWater->GetDY(); + trayStructure->AddNode(waterCoolManif, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += coolManifWater->GetDY() + coolManifAl->GetDY(); + trayStructure->AddNode(alCoolManif, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + xloc = inputCabsCu->GetDX(); + yloc += coolManifWater->GetDY() + inputCabsCu->GetDY() + + kSideCInputCablesTrans; + trayStructure->AddNode(cuInputCabs, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY(); + trayStructure->AddNode(plastInputCabs, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY(); + trayStructure->AddNode(alInputCabs, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY(); + trayStructure->AddNode(kaptonInputCabs, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY(); + trayStructure->AddNode(polyaxInputCabs, 1, + new TGeoTranslation( xloc, yloc, 0) ); + + trayStructure->AddNode(purCoolTubes , 1, 0); + trayStructure->AddNode(waterCoolTubes, 1, 0); + trayStructure->AddNode(airCoolTubes , 1, 0); + + xloc = optConnPBT->GetDX(); + yloc = 2*kSideCHalfThick + optConnPBT->GetDY(); + zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ(); + trayStructure->AddNode(pbtOptConn, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + trayStructure->AddNode(pbtOptConn, 2, + new TGeoTranslation( xloc, yloc,-zloc) ); + + yloc += optConnPBT->GetDY() + optConnSteel->GetDY(); + trayStructure->AddNode(steelOptConn, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + trayStructure->AddNode(steelOptConn, 2, + new TGeoTranslation( xloc, yloc,-zloc) ); + + yloc += optConnSteel->GetDY() + optConnAl->GetDY(); + trayStructure->AddNode(alOptConn, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + trayStructure->AddNode(alOptConn, 2, + new TGeoTranslation( xloc, yloc,-zloc) ); + + trayStructure->AddNode(optFibs, 1, + new TGeoTranslation( 0, 0, zloc) ); + trayStructure->AddNode(optFibs, 2, + new TGeoTranslation( 0, 0,-zloc) ); + + trayStructure->AddNode(cuOutputCabs , 1, 0); + trayStructure->AddNode(plastOutputCabs , 1, 0); + trayStructure->AddNode(alOutputCabs , 1, 0); + trayStructure->AddNode(kaptonOutputCabs, 1, 0); + trayStructure->AddNode(polyaxOutputCabs, 1, 0); + + xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX(); + yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY(); + trayStructure->AddNode(cuPCBBoards, 1, + new TGeoTranslation( xloc, yloc , 0) ); + + yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY(); + trayStructure->AddNode(epoxyPCBBoards, 1, + new TGeoTranslation( xloc, yloc , 0) ); + + yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY(); + trayStructure->AddNode(plastPCBBoards, 1, + new TGeoTranslation( xloc, yloc , 0) ); + + yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY(); + trayStructure->AddNode(steelPCBBoards, 1, + new TGeoTranslation( xloc, yloc , 0) ); + + yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY(); + trayStructure->AddNode(ppsPCBBoards, 1, + new TGeoTranslation( xloc, yloc , 0) ); + // Finally put everything in the mother volume alphafold = kSideCFoldAngle; @@ -4383,7 +7129,7 @@ void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SSD cable trays which are outside the ITS support cones // but still inside the TPC on Side A @@ -4923,7 +7669,7 @@ void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth, //______________________________________________________________________ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, - TGeoManager *mgr){ + const TGeoManager *mgr){ // // Creates the SSD cable trays which are outside the ITS support cones // but still inside the TPC on Side C @@ -4952,6 +7698,7 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, 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; @@ -4976,11 +7723,11 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, // Copper lies on the lower plate: get position of its points TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape()); xprof[0] = lowerplate->GetX(5); - yprof[0] = lowerplate->GetY(5); + yprof[0] = lowerplate->GetY(5) + kCablesYtrans; xprof[1] = lowerplate->GetX(4); - yprof[1] = lowerplate->GetY(4); + yprof[1] = lowerplate->GetY(4) + kCablesYtrans; xprof[2] = lowerplate->GetX(3); - yprof[2] = lowerplate->GetY(3); + yprof[2] = lowerplate->GetY(3) + kCablesYtrans; xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle); yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle); InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], @@ -5035,9 +7782,8 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, water->DefineSection(1, kServicesWidth/2); // The poliurethane inside the tray: a Xtru - TGeoXtru *PUR = new TGeoXtru(2); - PUR->SetName("ITSsuppSSDTrayCPUR"); - + TGeoXtru *pur = new TGeoXtru(2); + pur->SetName("ITSsuppSSDTrayCPUR"); xprof[0] = water->GetX(5); yprof[0] = water->GetY(5); xprof[1] = water->GetX(4); @@ -5051,9 +7797,9 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, xprof[5] = xprof[0]; yprof[5] = yprof[0] + kPoliUrethaneHeight; - PUR->DefinePolygon(6, xprof, yprof); - PUR->DefineSection(0, -kServicesWidth/2); - PUR->DefineSection(1, kServicesWidth/2); + pur->DefinePolygon(6, xprof, yprof); + pur->DefineSection(0, -kServicesWidth/2); + pur->DefineSection(1, kServicesWidth/2); // We have all shapes: now create the real volumes @@ -5090,7 +7836,7 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, trayWater->SetFillStyle(4000); // 0% transparent TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr", - PUR, medPUR); + pur, medPUR); trayPolyUr->SetVisibility(kTRUE); trayPolyUr->SetLineColor(kGray); // Gray @@ -5123,18 +7869,21 @@ void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, } //______________________________________________________________________ -TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoManager *mgr){ +void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray, + const TGeoManager *mgr){ // // Creates the forward SDD tray on Side A (0872/G/D/01) // // Input: +// tray : the TGeoVolumeAssembly to put the elements in // mgr : the GeoManager (used only to get the proper material) // // Output: // -// Return: a TGeoVolumeAssembly for the tray +// Return: // // Created: 08 Jan 2010 Mario Sitta +// Updated: 07 Sep 2010 Mario Sitta // // Technical data are taken from AutoCAD drawings, L.Simonetti technical // drawings and other (oral) information given by F.Tosello @@ -5168,9 +7917,7 @@ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoMana // The tray has a very complex shape, so it is made by assembling - // different elements (with some small simplifications): the result - // is a TGeoAssembly returned to the caller - TGeoVolumeAssembly *forwardTray = new TGeoVolumeAssembly("ITSsuppSDDForwardTray"); + // different elements (with some small simplifications) // The tray base: a BBox zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2; @@ -5307,53 +8054,53 @@ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoMana // Now build up the tray yloc = kForwardTrayThick/2; zloc = zlen; - forwardTray->AddNode(forwTrayBase, 1, - new TGeoTranslation(0, yloc, zloc) ); + tray->AddNode(forwTrayBase, 1, + new TGeoTranslation(0, yloc, zloc) ); xloc = kForwardTrayBaseHalfWide; - forwardTray->AddNode(forwTraySide1, 1, - new TGeoCombiTrans(xloc, 0, 0, + tray->AddNode(forwTraySide1, 1, + new TGeoCombiTrans(xloc, 0, 0, new TGeoRotation("",90,-90,-90))); xloc = -xloc + kForwardTrayThick; - forwardTray->AddNode(forwTraySide1, 2, - new TGeoCombiTrans(xloc, 0, 0, + tray->AddNode(forwTraySide1, 2, + new TGeoCombiTrans(xloc, 0, 0, new TGeoRotation("",90,-90,-90))); - forwardTray->AddNode(forwTraySide2, 1, 0); + tray->AddNode(forwTraySide2, 1, 0); zloc = kForwardTraySideLength; - forwardTray->AddNode(forwTraySide2, 2, - new TGeoCombiTrans(0, 0, zloc, + tray->AddNode(forwTraySide2, 2, + new TGeoCombiTrans(0, 0, zloc, new TGeoRotation("",90,-180,-90))); xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand; - forwardTray->AddNode(forwTraySide3, 1, - new TGeoCombiTrans(xloc, 0, 0, + tray->AddNode(forwTraySide3, 1, + new TGeoCombiTrans(xloc, 0, 0, new TGeoRotation("",90,-90,-90))); xloc = -xloc + kForwardTrayThick; - forwardTray->AddNode(forwTraySide3, 2, - new TGeoCombiTrans(xloc, 0, 0, + tray->AddNode(forwTraySide3, 2, + new TGeoCombiTrans(xloc, 0, 0, new TGeoRotation("",90,-90,-90))); xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand - kForwardTrayHorWingWide/2; yloc = traySide3->GetY(2) + kForwardTrayThick/2; zloc = kForwardTraySideLength - trayHorWing->GetDZ(); - forwardTray->AddNode(forwTrayHWing, 1, - new TGeoTranslation( xloc, yloc, zloc) ); - forwardTray->AddNode(forwTrayHWing, 2, - new TGeoTranslation(-xloc, yloc, zloc) ); + tray->AddNode(forwTrayHWing, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + tray->AddNode(forwTrayHWing, 2, + new TGeoTranslation(-xloc, yloc, zloc) ); xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand - kForwardTrayVertWingWide/2; yloc = traySide3->GetY(2) + trayVertWing->GetDY(); zloc = traySide3->GetX(3) + kForwardTrayThick/2; - forwardTray->AddNode(forwTrayVWing, 1, - new TGeoTranslation( xloc, yloc, zloc) ); - forwardTray->AddNode(forwTrayVWing, 2, - new TGeoTranslation(-xloc, yloc, zloc) ); + tray->AddNode(forwTrayVWing, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + tray->AddNode(forwTrayVWing, 2, + new TGeoTranslation(-xloc, yloc, zloc) ); - return forwardTray; + return; } //______________________________________________________________________ @@ -5730,8 +8477,8 @@ TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA( //______________________________________________________________________ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC( - const char *trayName, - TGeoManager *mgr){ + const char *trayName, + const TGeoManager *mgr){ // // Creates the SDD and SSD Trays on Side C which are supposedly identical @@ -6134,3 +8881,1317 @@ TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC( 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; +} +