X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySupport.cxx;h=cd65af0bdfafc4526ff47e660d8ccb2f33f6c0c7;hb=634a162510ff6ba3f9086f8aaf11713b0d0e6fe2;hp=f88b63a3e107c7c846a59c1e86799fa091d62d4f;hpb=a53658c691be6d93f97262c79dde35fd73660119;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySupport.cxx b/ITS/AliITSv11GeometrySupport.cxx index f88b63a3e10..cd65af0bdfa 100644 --- a/ITS/AliITSv11GeometrySupport.cxx +++ b/ITS/AliITSv11GeometrySupport.cxx @@ -25,7 +25,7 @@ // General Root includes #include // Root Geometry includes -#include +//#include #include #include #include @@ -42,2962 +42,6452 @@ ClassImp(AliITSv11GeometrySupport) #define SQ(A) (A)*(A) //______________________________________________________________________ -void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth){ - // Define the detail SPD support cone geometry. - // Inputs: - // TGeo Volume *moth The mother volume to place this object. - // Outputs: - // none. - // Return: - // none. - - SPDThermalSheald(moth); +void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr) +{ +// +// Creates the SPD thermal shield as a volume assembly +// and adds it to the mother volume +// (this is actually a merge of the previous SPDThermalSheald method +// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06 and the +// CreateSPDThermalShield method of AliITSv11Hybrid) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? ??? +// Updated: 11 Dec 2007 Mario Sitta +// +// Technical data are taken from: ALICE-Thermal Screen "Cone transition" +// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half +// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps) + + + // Dimensions of the Central shield + const Double_t kHalfLengthCentral = 400.*fgkmm; + const Double_t kThicknessCentral = 0.4*fgkmm; + const Double_t kInnerRadiusCentral = 8.1475*fgkcm; + const Double_t kOuterRadiusCentral = 9.9255*fgkcm; + const Double_t kInnerACentral = 3.1674*fgkcm; + const Double_t kInnerBCentral = 2.023 *fgkcm; + const Double_t kOuterACentral = 2.4374*fgkcm; + const Double_t kOuterBCentral = 3.8162*fgkcm; + // Dimensions of the EndCap shield + const Double_t kHalfLengthEndCap = 25.*fgkmm; + const Double_t kThicknessEndCap = 2.0*fgkmm; + const Double_t kInnerRadiusEndCap = 8.0775*fgkcm; + const Double_t kOuterRadiusEndCap = 9.9955*fgkcm; + const Double_t kInnerAEndCap = 3.1453*fgkcm; + const Double_t kInnerBEndCap = 2.0009*fgkcm; + const Double_t kOuterAEndCap = 2.4596*fgkcm; + const Double_t kOuterBEndCap = 3.8384*fgkcm; + // Dimensions of the Cone shield + const Double_t kHalfLengthCone = 145.*fgkmm; + const Double_t kThicknessCone = 0.3*fgkmm; + const Double_t kInnerRadialCone = 37.3*fgkcm; + const Double_t kOuterRadialCone = 39.0*fgkcm; + const Double_t kInnerACone = 14.2344*fgkcm; + // const Double_t kInnerBCone = 9.0915*fgkcm; + const Double_t kOuterACone = 9.5058*fgkcm; + // const Double_t kOuterBCone = 14.8831*fgkcm; + // Dimensions of the Flange's Ring and Wing + const Double_t kHalfLengthRing = 7.5*fgkmm; + const Double_t kThicknessRing = 0.3*fgkmm; + const Double_t kInnerRadiusRing = 37.3*fgkcm; + const Double_t kOuterRadiusRing = 42.0*fgkcm; + const Double_t kOuterRadiusWing = 49.25*fgkcm; + 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 kThicknessOmega = 0.3*fgkmm; + + // Local variables + Double_t x, y; + Double_t xshld[24], yshld[24]; + Double_t xair[24] , yair[24]; + 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 + // shields, again symmetric with respect to the XZ plane, and four + // half cones, symmetric with respect to the XZ plane too. + + 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); + + CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral, + kOuterACentral,kOuterBCentral,kOuterRadiusCentral, + kTheta,xshld,yshld); + + centralshape->DefinePolygon(24,xshld,yshld); + centralshape->DefineSection(0,-kHalfLengthCentral); + centralshape->DefineSection(1, kHalfLengthCentral); + + // Now rescale to get the air volume dimensions + InsidePoint(xshld[23], yshld[23], + xshld[ 0], yshld[ 0], + xshld[ 1], yshld[ 1], kThicknessCentral, + 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], kThicknessCentral, + xair[i], yair[i]); + } + InsidePoint(xshld[22], yshld[22], + xshld[23], yshld[23], + 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); + + // Create the Omega insert + TGeoXtru *centralomegashape = new TGeoXtru(2); + + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + + centralomegashape->DefinePolygon(48,xomega,yomega); + centralomegashape->DefineSection(0,-kHalfLengthCentral); + centralomegashape->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 *endcapshape = new TGeoXtru(2); + + CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap, + kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap, + kTheta,xshld,yshld); + + endcapshape->DefinePolygon(24,xshld,yshld); + endcapshape->DefineSection(0,-kHalfLengthEndCap); + endcapshape->DefineSection(1, kHalfLengthEndCap); + + // Now rescale to get the air volume dimensions + InsidePoint(xshld[23], yshld[23], + xshld[ 0], yshld[ 0], + xshld[ 1], yshld[ 1], kThicknessEndCap, + 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], kThicknessEndCap, + xair[i], yair[i]); + } + InsidePoint(xshld[22], yshld[22], + xshld[23], yshld[23], + xshld[ 0], yshld[ 0], kThicknessEndCap, + xair[23], yair[23]); + + // Create the air shape + TGeoXtru *endcapairshape = new TGeoXtru(2); + + endcapairshape->DefinePolygon(24,xair,yair); + endcapairshape->DefineSection(0,-kHalfLengthEndCap); + endcapairshape->DefineSection(1, kHalfLengthEndCap); + + // Create the Omega insert + TGeoXtru *endcapomegashape = new TGeoXtru(2); + + CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega); + + endcapomegashape->DefinePolygon(48,xomega,yomega); + endcapomegashape->DefineSection(0,-kHalfLengthEndCap); + endcapomegashape->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. + + // Filled portions + TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone); + + 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]); + + 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]); + + // Drawings give only the radius, convert it to the apothegm + Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone + - 0.25*kInnerACone*kInnerACone); + Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone + - 0.25*kOuterACone*kOuterACone); + + Double_t xco[4], yco[4], xci[4], yci[4]; + + for (Int_t i=0; i<2; i++) { + Double_t th = i*kTheta*TMath::RadToDeg(); + xco[2*i ] = kOuterRadiusCone*SinD(th) - 0.5*kOuterACone*CosD(th); + yco[2*i ] = kOuterRadiusCone*CosD(th) + 0.5*kOuterACone*SinD(th); + xci[2*i ] = kInnerRadiusCone*SinD(th) - 0.5*kInnerACone*CosD(th); + yci[2*i ] = kInnerRadiusCone*CosD(th) + 0.5*kInnerACone*SinD(th); + xco[2*i+1] = kOuterRadiusCone*SinD(th) + 0.5*kOuterACone*CosD(th); + yco[2*i+1] = kOuterRadiusCone*CosD(th) - 0.5*kOuterACone*SinD(th); + xci[2*i+1] = kInnerRadiusCone*SinD(th) + 0.5*kInnerACone*CosD(th); + yci[2*i+1] = kInnerRadiusCone*CosD(th) - 0.5*kInnerACone*SinD(th); + } + + sC1->SetVertex(4,xco[0],yco[0]); + sC1->SetVertex(5,xco[1],yco[1]); + sC1->SetVertex(6,xci[1],yci[1]); + sC1->SetVertex(7,xci[0],yci[0]); + + sC2->SetVertex(4,xco[1],yco[1]); + sC2->SetVertex(5,xco[2],yco[2]); + sC2->SetVertex(6,xci[2],yci[2]); + sC2->SetVertex(7,xci[1],yci[1]); + + // Air holes + TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone); + TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone); + + for(Int_t i=0; i<4; i++){ + InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0], + sC1->GetVertices()[((i+3)%4)*2+1], + sC1->GetVertices()[i*2+0], + sC1->GetVertices()[i*2+1], + sC1->GetVertices()[((i+1)%4)*2+0], + sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y); + sCh1->SetVertex(i,x,y); + + InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0], + sC1->GetVertices()[((i+3)%4 +4)*2+1], + sC1->GetVertices()[(i+4)*2+0], + sC1->GetVertices()[(i+4)*2+1], + sC1->GetVertices()[((i+1)%4 +4)*2+0], + sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y); + sCh1->SetVertex(i+4,x,y); + + InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0], + sC2->GetVertices()[((i+3)%4)*2+1], + sC2->GetVertices()[i*2+0], + sC2->GetVertices()[i*2+1], + sC2->GetVertices()[((i+1)%4)*2+0], + sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y); + sCh2->SetVertex(i,x,y); + + InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0], + sC2->GetVertices()[((i+3)%4 +4)*2+1], + sC2->GetVertices()[(i+4)*2+0], + sC2->GetVertices()[(i+4)*2+1], + sC2->GetVertices()[((i+1)%4 +4)*2+0], + sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y); + sCh2->SetVertex(i+4,x,y); + } + + // Finally the carbon fiber Ring with its Wings and their + // stesalite inserts. They are Tube and TubeSeg shapes + + TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing, + kHalfLengthRing); + + TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing, + kOuterRadiusRing-kThicknessRing, + kHalfLengthRing-kThicknessRing); + + Double_t angleWideWing, angleWideWingThickness; + angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg(); + angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg(); + + TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing, + kHalfLengthRing, 0, angleWideWing); + + TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing, + kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing, + angleWideWingThickness, angleWideWing-angleWideWingThickness); + + + // We have the shapes: now create the real volumes + + TGeoMedium *medSPDcf = mgr->GetMedium("ITS_SPD shield$"); + TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$"); + TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite + + TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield", + centralshape,medSPDcf); + 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); + + 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); + + 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 *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf); + ring->SetVisibility(kTRUE); + ring->SetLineColor(7); + ring->SetLineWidth(1); + + TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert", + ringinsertshape,medSPDste); + ringinsert->SetVisibility(kTRUE); + ringinsert->SetLineColor(3); // Green +// ringinsert->SetLineWidth(1); + ringinsert->SetFillColor(ringinsert->GetLineColor()); + ringinsert->SetFillStyle(4010); // 10% transparent + + ring->AddNode(ringinsert,1,0); + + TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf); + wing->SetVisibility(kTRUE); + wing->SetLineColor(7); + wing->SetLineWidth(1); + + TGeoVolume *winginsert = new TGeoVolume("SPDshieldringinsert", + winginsertshape,medSPDste); + winginsert->SetVisibility(kTRUE); + winginsert->SetLineColor(3); // Green +// winginsert->SetLineWidth(1); + winginsert->SetFillColor(winginsert->GetLineColor()); + winginsert->SetFillStyle(4010); // 10% transparent + + wing->AddNode(winginsert,1,0); + + + // Add all volumes in the assembly + vM->AddNode(centralshield,1,0); + vM->AddNode(centralshield,2,new TGeoRotation("",180,0,0)); + + vM->AddNode(endcapshield,1, + new TGeoTranslation(0,0, kHalfLengthCentral+kHalfLengthEndCap)); + vM->AddNode(endcapshield,2, + new TGeoTranslation(0,0,-kHalfLengthCentral-kHalfLengthEndCap)); + vM->AddNode(endcapshield,3,new TGeoCombiTrans( + 0, 0, kHalfLengthCentral+kHalfLengthEndCap, + new TGeoRotation("",180,0,0) ) ); + vM->AddNode(endcapshield,4,new TGeoCombiTrans( + 0, 0,-kHalfLengthCentral-kHalfLengthEndCap, + new TGeoRotation("",180,0,0) ) ); + + for (Int_t i=0; i<10; i++) { + Double_t thetaC12 = kTheta*TMath::RadToDeg(); + vM->AddNode(vC1,2*i+1, new TGeoCombiTrans( + 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone, + new TGeoRotation("",0, 0,i*thetaC12) ) ); + vM->AddNode(vC1,2*i+2, new TGeoCombiTrans( + 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone, + new TGeoRotation("",0,180,i*thetaC12) ) ); + vM->AddNode(vC2,2*i+1, new TGeoCombiTrans( + 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone, + new TGeoRotation("",0, 0,i*thetaC12) ) ); + vM->AddNode(vC2,2*i+2, new TGeoCombiTrans( + 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone, + new TGeoRotation("",0,180,i*thetaC12) ) ); + } + + vM->AddNode(ring,1,new TGeoTranslation(0, 0, + kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone + +kHalfLengthRing)); + vM->AddNode(ring,2,new TGeoTranslation(0, 0, + -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone + -kHalfLengthRing)); + + 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) )); + } + + // Some debugging if requested + if(GetDebug(1)){ + vM->PrintNodes(); + vM->InspectShape(); + } + + // Finally put the entire shield in the mother volume + moth->AddNode(vM,1,0); + + return; +} + +//______________________________________________________________________ +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 ) +{ +// +// Creates the proper sequence of X and Y coordinates to determine +// the base XTru polygon for the SPD thermal shapes +// +// Input: +// ina, inb : inner shape sides +// inr : inner radius +// oua, oub : outer shape sides +// our : outer radius +// t : theta angle +// +// Output: +// x, y : coordinate vectors [24] +// +// Created: 14 Nov 2007 Mario Sitta +// Updated: 11 Dec 2007 Mario Sitta +// + Double_t xlocal[6],ylocal[6]; + + //Create the first inner quadrant (X > 0) + FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal); + for (Int_t i=0; i<6; i++) { + x[i] = xlocal[i]; + y[i] = ylocal[i]; + } + + // Then reflex on the second quadrant (X < 0) + for (Int_t i=0; i<6; i++) { + x[23-i] = -x[i]; + y[23-i] = y[i]; + } + + // Now create the first outer quadrant (X > 0) + FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal); + for (Int_t i=0; i<6; i++) { + x[11-i] = xlocal[i]; + y[11-i] = ylocal[i]; + } + + // Finally reflex on the second quadrant (X < 0) + for (Int_t i=0; i<6; i++) { + x[12+i] = -x[11-i]; + y[12+i] = y[11-i]; + } + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::CreateSPDOmegaShape( + Double_t *xin, Double_t *yin, Double_t d, + Double_t *x, Double_t *y) +{ +// +// Creates the proper sequence of X and Y coordinates to determine +// the SPD Omega XTru polygon +// +// Input: +// xin, yin : coordinates of the air volume +// d : Omega shape thickness +// t : theta angle +// +// Output: +// x, y : coordinate vectors [48] +// +// Created: 17 Nov 2007 Mario Sitta +// Updated: 11 Dec 2007 Mario Sitta +// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one +// gives erroneous vertexes) +// + + // This vector contains the index of those points which coincide + // with the corresponding points in the air shape + Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23}; + + // First fill those vertexes corresponding to + // the edges aligned to the air shape edges + for (Int_t j=0; j<12; j++) { + x[*(indexAir2Omega+j)] = xin[j]; + y[*(indexAir2Omega+j)] = yin[j]; + } + + // Now get the coordinates of the first inner point + PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]); + + // Knowing this, the second internal point can be determined + InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]); + + // The third point is now computable + ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]); + + // Repeat this logic + InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]); + + ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]); + + InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]); + + ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]); + + InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]); + + ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]); + + InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]); + + // These need to be fixed explicitly + x[12] = x[11]; + y[12] = y[11] + d; + x[13] = x[10] + d; + y[13] = y[12]; + + // Finally reflect on the negative side + for (Int_t i=0; i<24; i++) { + x[24+i] = -x[23-i]; + y[24+i] = y[23-i]; + } + + // Wow ! We've finished + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b, + Double_t r, Double_t t, + Double_t *x, Double_t *y) +{ +// +// Creates the partial sequence of X and Y coordinates to determine +// the lateral part of the SPD thermal shield +// +// Input: +// a, b : shape sides +// r : radius +// t : theta angle +// +// Output: +// x, y : coordinate vectors [6] +// +// Created: 14 Nov 2007 Mario Sitta +// + x[0] = a/2; + y[0] = r; + + x[1] = x[0] + b * TMath::Cos(t/2); + y[1] = y[0] - b * TMath::Sin(t/2); + + x[2] = x[1] + a * TMath::Cos(t); + y[2] = y[1] - a * TMath::Sin(t); + + x[3] = x[2] + b * TMath::Cos(3*t/2); + y[3] = y[2] - b * TMath::Sin(3*t/2); + + x[4] = x[3] + a * TMath::Cos(2*t); + y[4] = y[3] - a * TMath::Sin(2*t); + + x[5] = x[4]; + y[5] = 0.; + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1, + Double_t x2, Double_t y2, Double_t d, + Double_t &x, Double_t &y) +{ +// +// Determines the X and Y of the first internal point of the Omega shape +// (i.e. the coordinates of a point given two parallel lines passing by +// two points and placed at a known distance) +// +// Input: +// x1, y1 : first point +// x2, y2 : second point +// d : distance between the two lines +// +// Output: +// x, y : coordinate of the point +// +// Created: 22 Feb 2009 Mario Sitta +// +//Begin_Html +/* + +*/ +//End_Html + + // The slope of the paralles lines at a distance d + Double_t m; + + // The parameters of the solving equation + // a x^2 - 2 b x + c = 0 + Double_t a = (x1 - x2)*(x1 - x2) - d*d; + Double_t b = (x1 - x2)*(y1 - y2); + Double_t c = (y1 - y2)*(y1 - y2) - d*d; + + // (Delta4 is Delta/4 because we use the reduced formula) + Double_t Delta4 = b*b - a*c; + + // Compute the slope of the two parallel lines + // (one of the two possible slopes, the one with the smaller + // absolute value is needed) + if (Delta4 < 0) { // Should never happen with our data, but just to be sure + x = -1; // x is expected positive, so this flags an error + return; + } else + m = (b + TMath::Sqrt(Delta4))/a; // b is negative with our data + + // Finally compute the coordinates of the point + x = x2 + (y1 - y2 - d)/m; + y = y1 - d; + + // Done + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1, + Double_t x2, Double_t y2, + Double_t x3, Double_t y3, + Double_t &x, Double_t &y) +{ +// +// Given two points (x1,y1) and (x2,y2), determines the point (x,y) +// lying on the line parallel to the line passing by these points, +// at a distance d and passing by the point (x3,y3), which is symmetric to +// the third point with respect to the axis of the segment delimited by +// the two first points. +// +// Input: +// x1, y1 : first point +// x2, y2 : second point +// x3, y3 : third point +// d : distance between the two lines +// +// Output: +// x, y : coordinate of the reflected point +// +// Created: 22 Feb 2009 Mario Sitta +// +//Begin_Html +/* + +*/ +//End_Html + + // The slope of the line passing by the first two points + Double_t k = (y2 - y1)/(x2 - x1); + + // The middle point of the segment 1-2 + Double_t xK = (x1 + x2)/2.; + Double_t yK = (y1 + y2)/2.; + + // The intercept between the axis of the segment 1-2 and the line + // passing by 3 and parallel to the line passing by 1-2 + Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1); + Double_t yH = k*(xH - x3) + y3; + + // The point symmetric to 3 with respect to H + x = 2*xH - x3; + y = 2*yH - y3; + + // Done + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr) +{ +// +// Creates the SDD support cone and cylinder geometry as a +// volume assembly and adds it to the mother volume +// (part of this code is taken or anyway inspired to SDDCone method +// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 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" +// (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D), +// private communication with B. Giraudo + + // Dimensions of the Central cylinder and flanges + const Double_t kCylinderHalfLength = (790.0/2)*fgkmm; + const Double_t kCylinderInnerR = (210.0/2)*fgkmm; + const Double_t kCylinderOuterR = (231.0/2)*fgkmm; + const Double_t kFlangeHalfLength = ( 15.0/2)*fgkmm; + const Double_t kFlangeInnerR = (210.5/2)*fgkmm; + const Double_t kFlangeOuterR = (230.5/2)*fgkmm; + const Double_t kInsertoHalfLength = + kCylinderHalfLength - 2*kFlangeHalfLength; +// const Double_t kCFThickness = kFlangeInnerR - kCylinderInnerR; + const Double_t kBoltDiameter = 6.0*fgkmm; // M6 screw + const Double_t kBoltDepth = 6.0*fgkmm; // In the flange + const Double_t kBoltRadius = (220.0/2)*fgkmm; // Radius in flange + const Double_t kThetaBolt = 30.0*fgkDegree; + const Int_t kNBolts = (Int_t)(360.0/kThetaBolt); + // Dimensions of the Cone + const Double_t kConeROutMin = (540.0/2)*fgkmm; + const Double_t kConeROutMax = (560.0/2)*fgkmm; + const Double_t kConeRCurv = 10.0*fgkmm; // Radius of curvature + const Double_t kConeRinMin = (210.0/2)*fgkmm; +// const Double_t kConeRinMax = (216.0/2)*fgkmm; + const Double_t kConeRinCylinder = (231.0/2)*fgkmm; + const Double_t kConeZCylinder = 192.0*fgkmm; + const Double_t kConeZOuterMilled = 23.0*fgkmm; + const Double_t kConeDZin = 15.0*fgkmm; // ??? + const Double_t kConeThickness = 10.0*fgkmm; // Rohacell + Carb.Fib. + const Double_t kConeTheta = 45.0*fgkDegree; // SDD cone angle + const Double_t kSinConeTheta = + TMath::Sin(kConeTheta*TMath::DegToRad()); + const Double_t kCosConeTheta = + TMath::Cos(kConeTheta*TMath::DegToRad()); + const Double_t kTanConeTheta = + TMath::Tan(kConeTheta*TMath::DegToRad()); + // Dimensions of the Cone Inserts + const Double_t kConeCFThickness = 1.5*fgkmm;//Carbon fiber thickness + // Dimensions of the Cone Holes + const Double_t kHole1RMin = (450.0/2)*fgkmm; + const Double_t kHole1RMax = (530.0/2)*fgkmm; + const Double_t kHole2RMin = (280.0/2)*fgkmm; + const Double_t kHole2RMax = (375.0/2)*fgkmm; + const Double_t kHole1Phi = 25.0*fgkDegree; + const Double_t kHole2Phi = 50.0*fgkDegree; + const Double_t kHole3RMin = 205.0*fgkmm; + const Double_t kHole3DeltaR = 15*fgkmm; + const Double_t kHole3Width = 30*fgkmm; + const Int_t kNHole3 = 6 ; + const Double_t kHole4RMin = 116.0*fgkmm; + const Double_t kHole4DeltaR = 15*fgkmm; + const Double_t kHole4Width = 30*fgkmm; + // const Int_t kNHole4 = 3 ; + // Fraction of materials in holes + const Double_t kHolePlasticFrac = 0.55846; + const Double_t kHoleCuFrac = 0.06319; + const Double_t kHoleGlassFrac = 0.02652; + + // Local variables + Double_t x, y, z, t, dza, rmin, rmax; + + + // Recover the needed materials + TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$"); + TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$"); + TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite + TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$"); + TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$"); + TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$"); + TGeoMedium *medSDDCu = mgr->GetMedium("ITS_COPPER$"); + TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$"); + + // First define the geometrical shapes + + // Central cylinder with its internal foam and the lateral flanges: + // a carbon fiber Tube which contains a rohacell Tube and two + // stesalite Tube's + TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR, + kCylinderHalfLength); + + TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR, + kInsertoHalfLength); + + TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR, + kFlangeHalfLength); + + // The flange bolt: it is a Tube + TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth); + + // Debug if requested + if (GetDebug(1)) { + cylindershape->InspectShape(); + insertoshape->InspectShape(); + flangeshape->InspectShape(); + boltshape->InspectShape(); + } + + + // We have the shapes: now create the real volumes + + TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder", + cylindershape,medSDDcf); + cfcylinder->SetVisibility(kTRUE); + cfcylinder->SetLineColor(4); // Blue + cfcylinder->SetLineWidth(1); + cfcylinder->SetFillColor(cfcylinder->GetLineColor()); + cfcylinder->SetFillStyle(4000); // 0% transparent + + TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder", + insertoshape,medSDDroh); + foamcylinder->SetVisibility(kTRUE); + foamcylinder->SetLineColor(3); // Green + foamcylinder->SetLineWidth(1); + foamcylinder->SetFillColor(foamcylinder->GetLineColor()); + foamcylinder->SetFillStyle(4050); // 50% transparent + + TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder", + flangeshape,medSDDste); + flangecylinder->SetVisibility(kTRUE); + flangecylinder->SetLineColor(2); // Red + flangecylinder->SetLineWidth(1); + flangecylinder->SetFillColor(flangecylinder->GetLineColor()); + flangecylinder->SetFillStyle(4050); // 50% transparent + + TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss); + bolt->SetVisibility(kTRUE); + bolt->SetLineColor(1); // Black + bolt->SetLineWidth(1); + bolt->SetFillColor(bolt->GetLineColor()); + bolt->SetFillStyle(4050); // 50% transparent + + // Mount up the cylinder + for(Int_t i=0; iAddNode(bolt, i+1, new TGeoTranslation("",x,y,z)); + } + + cfcylinder->AddNode(foamcylinder,1,0); + cfcylinder->AddNode(flangecylinder,1, + new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength)); + cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans( + 0, 0, -kInsertoHalfLength-kFlangeHalfLength, + new TGeoRotation("",0,180,0) ) ); + + + // SDD Support Cone with its internal inserts: a carbon fiber Pcon + // with holes which contains a stesalite Pcon which on turn contains a + // rohacell Pcon + + dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta; + + TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10); + + coneshape->Z(0) = 0.0; + coneshape->Rmin(0) = kConeROutMin; + coneshape->Rmax(0) = kConeROutMax; + + coneshape->Z(1) = kConeZOuterMilled - dza; + coneshape->Rmin(1) = coneshape->GetRmin(0); + coneshape->Rmax(1) = coneshape->GetRmax(0); + + coneshape->Z(2) = kConeZOuterMilled; + coneshape->Rmax(2) = coneshape->GetRmax(0); + + RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1), + coneshape->GetRmin(1),kConeTheta,z,rmin); + coneshape->Z(3) = z; + coneshape->Rmin(3) = rmin; + + coneshape->Rmin(2) = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2)); + + RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2), + coneshape->GetRmax(2),kConeTheta,z,rmax); + coneshape->Z(4) = z; + coneshape->Rmax(4) = rmax; + coneshape->Rmin(4) = RminFromZpCone(coneshape,3,kConeTheta, + coneshape->GetZ(4),0.0); + + coneshape->Rmax(3) = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3)); + + coneshape->Z(6) = kConeZCylinder - kConeDZin; + + RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0, + 90.0-kConeTheta,z,rmin); + coneshape->Z(5) = z; + coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z); + coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z); + + RadiusOfCurvature(kConeRCurv,90.-kConeTheta, + 0.0,coneshape->Rmin(5),90.0,z,rmin); + coneshape->Rmin(6) = rmin; + coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta, + coneshape->GetZ(6)); + + coneshape->Z(7) = coneshape->GetZ(6); + coneshape->Rmin(7) = kConeRinMin; + coneshape->Rmax(7) = coneshape->GetRmax(6); + + coneshape->Rmin(8) = kConeRinMin; + + RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder, + 90.0-kConeTheta,z,rmax); + coneshape->Z(8) = z; + coneshape->Rmax(8) = rmax; + + coneshape->Z(9) = kConeZCylinder; + coneshape->Rmin(9) = kConeRinMin; + coneshape->Rmax(9) = kConeRinCylinder; + + + // SDD Cone Insert: another Pcon + Double_t x0, y0, x1, y1, x2, y2; + TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9); + + coneinsertshape->Z(0) = coneshape->GetZ(0) + kConeCFThickness; + coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness; + coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness; + + x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0); + x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1); + x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2); + InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin); + coneinsertshape->Z(1) = z; + coneinsertshape->Rmin(1) = rmin; + coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0); + + x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1); + x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2); + x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3); + InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax); + coneinsertshape->Z(2) = z; + coneinsertshape->Rmax(2) = rmax; + + x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2); + x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3); + x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4); + InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin); + coneinsertshape->Z(3) = z; + coneinsertshape->Rmin(3) = rmin; + + x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1); + x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3); + coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1, + coneinsertshape->Z(2)); + + x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3); + x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4); + x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5); + InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax); + coneinsertshape->Z(4) = z; + coneinsertshape->Rmax(4) = rmax; + + x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2); + x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4); + coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1, + coneinsertshape->Z(3)); + + x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4); + x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5); + x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6); + InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin); + coneinsertshape->Z(5) = z; + coneinsertshape->Rmin(5) = rmin; + coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) - + kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4)); + + x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3); + x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5); + coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1, + coneinsertshape->Z(4)); + + x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5); + x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6); + x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7); + InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin); + coneinsertshape->Z(6) = z; + coneinsertshape->Rmin(6) = rmin; + coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) - + kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4)); + + coneinsertshape->Z(7) = coneinsertshape->GetZ(6); + coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness; + coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6); + + coneinsertshape->Z(8) = coneshape->GetZ(9) - kConeCFThickness; + coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7); + coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) - + kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4)); + + // SDD Cone Foam: another Pcon + TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4); + + RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1), + coneinsertshape->GetRmin(1),kConeTheta,z,rmin); + + conefoamshape->Z(0) = z; + conefoamshape->Rmin(0) = rmin; + conefoamshape->Rmax(0) = conefoamshape->GetRmin(0); + + conefoamshape->Z(1) = conefoamshape->GetZ(0)+ + (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta; + conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta, + conefoamshape->GetZ(1)); + conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + conefoamshape->GetZ(1)); + + conefoamshape->Z(2) = coneshape->GetZ(5)-kConeCFThickness; + conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta, + conefoamshape->GetZ(2)); + conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + conefoamshape->GetZ(2)); + + conefoamshape->Z(3) = coneinsertshape->GetZ(5)+ + (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta; + conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + conefoamshape->GetZ(3)); + conefoamshape->Rmin(3) = conefoamshape->GetRmax(3); + + // SDD Cone Holes: Pcon's + // A single hole volume gives an overlap with coneinsert, so + // three contiguous volumes are created: one to be put in the cone foam + // and two in the cone carbon fiber envelope + TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4); + + hole1shape->Rmin(0) = kHole1RMax; + hole1shape->Rmax(0) = hole1shape->GetRmin(0); + hole1shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta, + hole1shape->GetRmin(0)); + + hole1shape->Rmax(1) = hole1shape->GetRmax(0); + hole1shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole1shape->GetRmax(1)); + hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta, + hole1shape->GetZ(1)); + + hole1shape->Rmin(2) = kHole1RMin; + hole1shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta, + hole1shape->GetRmin(2)); + hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta, + hole1shape->GetZ(2)); + + hole1shape->Rmin(3) = hole1shape->GetRmin(2); + hole1shape->Rmax(3) = hole1shape->GetRmin(3); + hole1shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole1shape->GetRmax(3)); + + TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4); + + hole11shape->Rmin(0) = kHole1RMax; + hole11shape->Rmax(0) = hole11shape->GetRmin(0); + hole11shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta, + hole11shape->GetRmin(0)); + + hole11shape->Rmax(1) = hole11shape->GetRmax(0); + hole11shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole11shape->GetRmax(1)); + hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta, + hole11shape->GetZ(1)); + + hole11shape->Rmin(2) = kHole1RMin; + hole11shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta, + hole11shape->GetRmin(2)); + hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta, + hole11shape->GetZ(2)); + + hole11shape->Rmin(3) = hole11shape->GetRmin(2); + hole11shape->Rmax(3) = hole11shape->GetRmin(3); + hole11shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole11shape->GetRmax(3)); + + TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4); + + hole12shape->Rmin(0) = kHole1RMax; + hole12shape->Rmax(0) = hole12shape->GetRmin(0); + hole12shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole12shape->GetRmin(0)); + + hole12shape->Rmax(1) = hole12shape->GetRmax(0); + hole12shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole12shape->GetRmax(1)); + hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + hole12shape->GetZ(1)); + + hole12shape->Rmin(2) = kHole1RMin; + hole12shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole12shape->GetRmin(2)); + hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta, + hole12shape->GetZ(2)); + + hole12shape->Rmin(3) = hole12shape->GetRmin(2); + hole12shape->Rmax(3) = hole12shape->GetRmin(3); + hole12shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole12shape->GetRmax(3)); + + // + TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4); + + hole2shape->Rmin(0) = kHole2RMax; + hole2shape->Rmax(0) = hole2shape->GetRmin(0); + hole2shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta, + hole2shape->GetRmin(0)); + + hole2shape->Rmax(1) = hole2shape->GetRmax(0); + hole2shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole2shape->GetRmax(1)); + hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta, + hole2shape->GetZ(1)); + + hole2shape->Rmin(2) = kHole2RMin; + hole2shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta, + hole2shape->GetRmin(2)); + hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta, + hole2shape->GetZ(2)); + + hole2shape->Rmin(3) = hole2shape->GetRmin(2); + hole2shape->Rmax(3) = hole2shape->GetRmin(3); + hole2shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole2shape->GetRmax(3)); + + TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4); + + hole21shape->Rmin(0) = kHole2RMax; + hole21shape->Rmax(0) = hole21shape->GetRmin(0); + hole21shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta, + hole21shape->GetRmin(0)); + + hole21shape->Rmax(1) = hole21shape->GetRmax(0); + hole21shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole21shape->GetRmax(1)); + hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta, + hole21shape->GetZ(1)); + + hole21shape->Rmin(2) = kHole2RMin; + hole21shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta, + hole21shape->GetRmin(2)); + hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta, + hole21shape->GetZ(2)); + + hole21shape->Rmin(3) = hole21shape->GetRmin(2); + hole21shape->Rmax(3) = hole21shape->GetRmin(3); + hole21shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole21shape->GetRmax(3)); + + TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4); + + hole22shape->Rmin(0) = kHole2RMax; + hole22shape->Rmax(0) = hole22shape->GetRmin(0); + hole22shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole22shape->GetRmin(0)); + + hole22shape->Rmax(1) = hole22shape->GetRmax(0); + hole22shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole22shape->GetRmax(1)); + hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + hole22shape->GetZ(1)); + + hole22shape->Rmin(2) = kHole2RMin; + hole22shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole22shape->GetRmin(2)); + hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta, + hole22shape->GetZ(2)); + + hole22shape->Rmin(3) = hole22shape->GetRmin(2); + hole22shape->Rmax(3) = hole22shape->GetRmin(3); + hole22shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole22shape->GetRmax(3)); + + // + Double_t holePhi; + holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg(); + + TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR; + hole3shape->Rmax(0) = hole3shape->GetRmin(0); + hole3shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta, + hole3shape->GetRmin(0)); + + hole3shape->Rmax(1) = hole3shape->GetRmax(0); + hole3shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole3shape->GetRmax(1)); + hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta, + hole3shape->GetZ(1)); + + hole3shape->Rmin(2) = kHole3RMin; + hole3shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta, + hole3shape->GetRmin(2)); + hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta, + hole3shape->GetZ(2)); + + hole3shape->Rmin(3) = hole3shape->GetRmin(2); + hole3shape->Rmax(3) = hole3shape->GetRmin(3); + hole3shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta, + hole3shape->GetRmax(3)); + + TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR; + hole31shape->Rmax(0) = hole31shape->GetRmin(0); + hole31shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta, + hole31shape->GetRmin(0)); + + hole31shape->Rmax(1) = hole31shape->GetRmax(0); + hole31shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole31shape->GetRmax(1)); + hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta, + hole31shape->GetZ(1)); + + hole31shape->Rmin(2) = kHole3RMin; + hole31shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta, + hole31shape->GetRmin(2)); + hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta, + hole31shape->GetZ(2)); + + hole31shape->Rmin(3) = hole31shape->GetRmin(2); + hole31shape->Rmax(3) = hole31shape->GetRmin(3); + hole31shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta, + hole31shape->GetRmax(3)); + + TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR; + hole32shape->Rmax(0) = hole32shape->GetRmin(0); + hole32shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole32shape->GetRmin(0)); + + hole32shape->Rmax(1) = hole32shape->GetRmax(0); + hole32shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole32shape->GetRmax(1)); + hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta, + hole32shape->GetZ(1)); + + hole32shape->Rmin(2) = kHole3RMin; + hole32shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta, + hole32shape->GetRmin(2)); + hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta, + hole32shape->GetZ(2)); + + hole32shape->Rmin(3) = hole32shape->GetRmin(2); + hole32shape->Rmax(3) = hole32shape->GetRmin(3); + hole32shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole32shape->GetRmax(3)); + + // + holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg(); + + TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR; + hole4shape->Rmax(0) = hole4shape->GetRmin(0); + hole4shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta, + hole4shape->GetRmin(0)); + + hole4shape->Rmax(1) = hole4shape->GetRmax(0); + hole4shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta, + hole4shape->GetRmax(1)); + hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta, + hole4shape->GetZ(1)); + + hole4shape->Rmin(2) = kHole4RMin; + hole4shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta, + hole4shape->GetRmin(2)); + hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta, + hole4shape->GetZ(2)); + + hole4shape->Rmin(3) = hole4shape->GetRmin(2); + hole4shape->Rmax(3) = hole4shape->GetRmin(3); + 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(); + coneinsertshape->InspectShape(); + conefoamshape->InspectShape(); + hole1shape->InspectShape(); + hole2shape->InspectShape(); + hole3shape->InspectShape(); + hole4shape->InspectShape(); + } + + + // We have the shapes: now create the real volumes + + TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone", + coneshape,medSDDcf); + cfcone->SetVisibility(kTRUE); + cfcone->SetLineColor(4); // Blue + cfcone->SetLineWidth(1); + cfcone->SetFillColor(cfcone->GetLineColor()); + cfcone->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert", + coneinsertshape,medSDDste); + cfconeinsert->SetVisibility(kTRUE); + cfconeinsert->SetLineColor(2); // Red + cfconeinsert->SetLineWidth(1); + cfconeinsert->SetFillColor(cfconeinsert->GetLineColor()); + cfconeinsert->SetFillStyle(4050); // 50% transparent + + TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam", + conefoamshape,medSDDroh); + cfconefoam->SetVisibility(kTRUE); + cfconefoam->SetLineColor(7); // Light blue + cfconefoam->SetLineWidth(1); + cfconefoam->SetFillColor(cfconefoam->GetLineColor()); + cfconefoam->SetFillStyle(4050); // 50% transparent + + TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1", + hole1shape,medSDDair); + hole1->SetVisibility(kTRUE); + hole1->SetLineColor(5); // Yellow + hole1->SetLineWidth(1); + hole1->SetFillColor(hole1->GetLineColor()); + hole1->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11", + hole11shape,medSDDair); + hole11->SetVisibility(kTRUE); + hole11->SetLineColor(5); // Yellow + hole11->SetLineWidth(1); + hole11->SetFillColor(hole11->GetLineColor()); + hole11->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12", + hole12shape,medSDDair); + hole12->SetVisibility(kTRUE); + hole12->SetLineColor(5); // Yellow + hole12->SetLineWidth(1); + 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); + hole2->SetLineColor(5); // Yellow + hole2->SetLineWidth(1); + hole2->SetFillColor(hole2->GetLineColor()); + hole2->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21", + hole21shape,medSDDair); + hole21->SetVisibility(kTRUE); + hole21->SetLineColor(5); // Yellow + hole21->SetLineWidth(1); + hole21->SetFillColor(hole21->GetLineColor()); + hole21->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22", + hole22shape,medSDDair); + hole22->SetVisibility(kTRUE); + hole22->SetLineColor(5); // Yellow + hole22->SetLineWidth(1); + 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); + hole3->SetLineColor(5); // Yellow + hole3->SetLineWidth(1); + hole3->SetFillColor(hole3->GetLineColor()); + hole3->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31", + hole31shape,medSDDair); + hole31->SetVisibility(kTRUE); + hole31->SetLineColor(5); // Yellow + hole31->SetLineWidth(1); + hole31->SetFillColor(hole31->GetLineColor()); + hole31->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32", + hole32shape,medSDDair); + hole32->SetVisibility(kTRUE); + hole32->SetLineColor(5); // Yellow + hole32->SetLineWidth(1); + hole32->SetFillColor(hole32->GetLineColor()); + hole32->SetFillStyle(4090); // 90% transparent + + TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4", + hole4shape,medSDDair); + hole4->SetVisibility(kTRUE); + hole4->SetLineColor(5); // Yellow + hole4->SetLineWidth(1); + hole4->SetFillColor(hole4->GetLineColor()); + hole4->SetFillStyle(4090); // 90% transparent + + // 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)); + cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH)); + cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH)); + } + + for (Int_t i=0; i<6; i++) { + Double_t phiH = i*60.0; + cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH)); + cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH)); + cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH)); + } + + for (Int_t i=0; iAddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0)); + cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0)); + cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0)); + } + + cfcone->AddNode(cfconeinsert,1,0); + +/* + for (Int_t i=0; iAddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0)); + } +*/ + // Finally put everything in the mother volume + moth->AddNode(cfcylinder,1,0); + + z = coneshape->Z(9); + moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength)); + moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0, z + kCylinderHalfLength, + new TGeoRotation("", 0, 180, 0) )); + + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr) +{ +// +// Creates the SSD support cone and cylinder geometry. as a +// volume assembly and adds it to the mother volume +// (part of this code is taken or anyway inspired to SSDCone method +// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 08 Mar 2008 Mario Sitta +// +// Technical data are taken from: "ITS Supporto Generale" (technical +// drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale +// Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private +// communication with B. Giraudo +// +// Updated: 11 Apr 2008 Mario Sitta +// Measures from drawings give overlaps with SPD thermal shield wings, +// so the terminal part of the SSD cone was reduced +// +// Updated: 30 Mar 2010 Mario Sitta +// Following M. van Leeuwen's suggestion on material budget, the thickness +// of the carbon fiber cylinder was increased from 0.6 to 0.625mm + + // Dimensions of the Central cylinder and flanges + const Double_t kCylinderHalfLength = (1144.0/2) *fgkmm; + const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm; + const Double_t kCylinderThickness = 0.625*fgkmm; + const Double_t kFoamHalfLength = (1020.0/2) *fgkmm; + const Double_t kFoamThickness = 5.0 *fgkmm; + const Double_t kFlangeHalfLength = + (kCylinderHalfLength-kFoamHalfLength)/2.; + const Double_t kFlangeInnerRadius = ( 563.0/2) *fgkmm; + // Dimensions of the Cone + const Double_t kConeROuterMin = ( 957.0/2) *fgkmm; + const Double_t kConeROuterMax = ( 997.0/2) *fgkmm; + const Double_t kConeRInnerMin = ( 564.0/2) *fgkmm; + const Double_t kConeRCurv1 = 10.0 *fgkmm; + const Double_t kConeRCurv2 = 25.0 *fgkmm; + const Double_t kConeCent1RCurv2 = ( 578.0/2) *fgkmm; + const Double_t kConeCent2RCurv2 = ( 592.0/2) *fgkmm; +// const Double_t kConeZOuterRing = 47.0 *fgkmm; +// const Double_t kConeZOuterRingInside = 30.25*fgkmm; +// const Double_t kConeZInnerRing = 161.5 *fgkmm; +// const Double_t kConeZLength = 176.5 *fgkmm; + const Double_t kConeZOuterRing = 38.5 *fgkmm; + const Double_t kConeZOuterRingInside = 22.2 *fgkmm; + const Double_t kConeZInnerRing = 153.0 *fgkmm; + const Double_t kConeZLength = 168.0 *fgkmm; + const Double_t kConeZPosition = kConeZLength + kCylinderHalfLength; + const Double_t kConeThickness = 13.0 *fgkmm; // Cone thickness + const Double_t kConeTheta = 39.1 *fgkDegree; // Cone angle + const Double_t kSinConeTheta = + TMath::Sin(kConeTheta*TMath::DegToRad()); + const Double_t kCosConeTheta = + TMath::Cos(kConeTheta*TMath::DegToRad()); + // Dimensions of the Foam cores + const Double_t kConeFoam1Length = 112.3 *fgkmm; + const Double_t kConeFoam2Length = 58.4 *fgkmm; + // Dimensions of the Cone Holes + const Double_t kCoolingHoleWidth = 40.0 *fgkmm; + const Double_t kCoolingHoleHight = 30.0 *fgkmm; + const Double_t kCoolingHoleRmin = 350.0 *fgkmm; + const Double_t kCoolingHolePhi = 45.0 *fgkDegree; + const Double_t kMountingHoleWidth = 20.0 *fgkmm; + const Double_t kMountingHoleHight = 20.0 *fgkmm; + const Double_t kMountingHoleRmin = 317.5 *fgkmm; + const Double_t kMountingHolePhi = 60.0 *fgkDegree; + const Double_t kCableHoleRin = ( 800.0/2) *fgkmm; + const Double_t kCableHoleRout = ( 920.0/2) *fgkmm; + const Double_t kCableHoleWidth = 200.0 *fgkmm; +// const Double_t kCableHoleAngle = 42.0 *fgkDegree; + // Dimensions of the Cone Wings + const Double_t kWingRmax = 527.5 *fgkmm; + const Double_t kWingWidth = 70.0 *fgkmm; + const Double_t kWingHalfThick = ( 10.0/2) *fgkmm; + const Double_t kThetaWing = 45.0 *fgkDegree; + // Dimensions of the SSD-SDD Mounting Brackets + const Double_t kBracketRmin = ( 541.0/2) *fgkmm;// See SDD ROutMin + const Double_t kBracketRmax = ( 585.0/2) *fgkmm; + const Double_t kBracketHalfLength = ( 4.0/2) *fgkmm; + const Double_t kBracketPhi = (70.*fgkmm/kBracketRmax)*fgkRadian; + // Common data + const Double_t kCFThickness = 0.75*fgkmm; //Carb. fib. thick. + + + // Local variables + Double_t rmin1, rmin2, rmax, z; + + // + //Begin_Html + /* + +

+ + ITS SSD central support and thermal shield cylinder. + +

+ */ + //End_Html + // + + // Central cylinder with its internal foam and the lateral flanges: + // a carbon fiber Pcon which contains a rohacell Tube and two + // stesalite Cone's + TGeoPcon *externalcylshape = new TGeoPcon(0,360,4); + + rmax = kCylinderOuterRadius; + rmin1 = kFlangeInnerRadius - kCylinderThickness; + rmin2 = rmax - 2*kCylinderThickness - kFoamThickness; + externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax); + externalcylshape->DefineSection(1,-kFoamHalfLength ,rmin2,rmax); + externalcylshape->DefineSection(2, kFoamHalfLength ,rmin2,rmax); + externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax); + + rmax = kCylinderOuterRadius - kCylinderThickness; + rmin1 = rmax - kFoamThickness; + TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength); + + rmax = kCylinderOuterRadius - kCylinderThickness; + rmin1 = rmax - kFoamThickness; + rmin2 = kFlangeInnerRadius; + TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength, + rmin1,rmax,rmin2,rmax); + + + // We have the shapes: now create the real volumes + + TGeoMedium *medSSDcf = mgr->GetMedium("ITS_SSD C (M55J)$"); + TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$"); + TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite + TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$"); + TGeoMedium *medSSDal = mgr->GetMedium("ITS_ALUMINUM$"); + + TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder", + externalcylshape,medSSDcf); + cfcylinder->SetVisibility(kTRUE); + cfcylinder->SetLineColor(4); // blue + cfcylinder->SetLineWidth(1); + cfcylinder->SetFillColor(cfcylinder->GetLineColor()); + cfcylinder->SetFillStyle(4000); // 0% transparent + + TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder", + foamshape,medSSDroh); + foamcylinder->SetVisibility(kTRUE); + foamcylinder->SetLineColor(3); // green + foamcylinder->SetLineWidth(1); + foamcylinder->SetFillColor(foamcylinder->GetLineColor()); + foamcylinder->SetFillStyle(4050); // 50% transparent + + TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder", + flangeshape,medSSDste); + flangecylinder->SetVisibility(kTRUE); + flangecylinder->SetLineColor(2); // red + flangecylinder->SetLineWidth(1); + flangecylinder->SetFillColor(flangecylinder->GetLineColor()); + flangecylinder->SetFillStyle(4050); // 50% transparent + + // Mount up the cylinder + cfcylinder->AddNode(foamcylinder,1,0); + cfcylinder->AddNode(flangecylinder,1, + new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength)); + cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans( + 0, 0, -kFoamHalfLength-kFlangeHalfLength, + new TGeoRotation("",0,180,0) ) ); + + + // The whole Cone as an assembly + TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone"); + + + // SSD Support Cone with its internal inserts: a carbon fiber Pcon + // with holes which contains a stesalite Pcon which on turn contains a + // rohacell Pcon + TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12); + + coneshape->Z(0) = 0.0; + coneshape->Rmin(0) = kConeROuterMin; + coneshape->Rmax(0) = kConeROuterMax; + + coneshape->Z(1) = kConeZOuterRingInside - kConeRCurv1; + coneshape->Rmin(1) = coneshape->GetRmin(0); + coneshape->Rmax(1) = coneshape->GetRmax(0); + + coneshape->Z(2) = kConeZOuterRingInside; + coneshape->Rmin(2) = coneshape->GetRmin(1) - kConeRCurv1; + coneshape->Rmax(2) = coneshape->GetRmax(0); + + coneshape->Z(3) = coneshape->GetZ(2); + coneshape->Rmax(3) = coneshape->GetRmax(0); + + coneshape->Z(4) = kConeZOuterRing - kConeRCurv1; + coneshape->Rmax(4) = coneshape->GetRmax(0); + + coneshape->Z(5) = kConeZOuterRing; + coneshape->Rmax(5) = coneshape->GetRmax(4) - kConeRCurv1; + + coneshape->Z(6) = coneshape->GetZ(5); + + RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2, + 90.0-kConeTheta,z,rmin1); + coneshape->Z(7) = z; + coneshape->Rmin(7) = rmin1; + + coneshape->Rmin(3) = RminFromZpCone(coneshape,7,90.-kConeTheta, + coneshape->GetZ(3)); + + coneshape->Rmin(4) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4)); + + coneshape->Rmin(5) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5)); + + coneshape->Rmin(6) = coneshape->GetRmin(5); + + coneshape->Z(8) = kConeZInnerRing; + coneshape->Rmin(8) = kConeCent1RCurv2; + + coneshape->Z(9) = coneshape->GetZ(8); + coneshape->Rmin(9) = kConeRInnerMin; + + RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2, + 90.0-kConeTheta,z,rmax); + + coneshape->Z(10) = z; + coneshape->Rmin(10) = coneshape->GetRmin(9); + coneshape->Rmax(10) = rmax; + + coneshape->Rmax(6) = RmaxFromZpCone(coneshape,10,90.-kConeTheta, + coneshape->GetZ(6)); + + coneshape->Rmax(7) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7)); + + coneshape->Rmax(8) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8)); + + coneshape->Rmax(9) = coneshape->GetRmax(8); + + coneshape->Z(11) = kConeZLength; + coneshape->Rmin(11) = coneshape->GetRmin(10); + coneshape->Rmax(11) = kConeCent2RCurv2; + + // SSD Cone Insert: another Pcon + Double_t x0, y0, x1, y1, x2, y2; + TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12); + + coneinsertshape->Z(0) = coneshape->GetZ(0) + kCFThickness; + coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kCFThickness; + coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kCFThickness; + + x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0); + x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1); + x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(1) = z; + coneinsertshape->Rmin(1) = rmin1; + coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0); + + x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1); + x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2); + x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(2) = z; + coneinsertshape->Rmin(2) = rmin1; + coneinsertshape->Rmax(2) = coneinsertshape->GetRmax(1); + + x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2); + x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3); + x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(3) = z; + coneinsertshape->Rmin(3) = rmin1; + coneinsertshape->Rmax(3) = coneinsertshape->GetRmax(2); + + x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3); + x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4); + x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5); + InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax); + coneinsertshape->Z(4) = z; + coneinsertshape->Rmax(4) = rmax; + + x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4); + x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5); + x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6); + InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax); + coneinsertshape->Z(5) = z; + coneinsertshape->Rmax(5) = rmax; + + x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5); + x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6); + x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7); + InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax); + coneinsertshape->Z(6) = z; + coneinsertshape->Rmax(6) = rmax; + + x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6); + x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7); + x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(7) = z; + coneinsertshape->Rmin(7) = rmin1; + + coneinsertshape->Rmin(4) = RminFrom2Points(coneinsertshape,3,7, + coneinsertshape->GetZ(4)); + + coneinsertshape->Rmin(5) = RminFrom2Points(coneinsertshape,3,7, + coneinsertshape->GetZ(5)); + + coneinsertshape->Rmin(6) = coneinsertshape->GetRmin(5); + + x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7); + x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8); + x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(8) = z; + coneinsertshape->Rmin(8) = rmin1; + + x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8); + x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9); + x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10); + InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1); + coneinsertshape->Z(9) = z; + coneinsertshape->Rmin(9) = rmin1; + + x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9); + x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10); + x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11); + InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax); + coneinsertshape->Z(10) = z; + coneinsertshape->Rmax(10) = rmax; + coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9); + + coneinsertshape->Rmax(7) = RmaxFrom2Points(coneinsertshape,6,10, + coneinsertshape->GetZ(7)); + + coneinsertshape->Rmax(8) = RmaxFrom2Points(coneinsertshape,6,10, + coneinsertshape->GetZ(8)); + + coneinsertshape->Rmax(9) = coneinsertshape->GetRmax(8); + + x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10); + x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11); + x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11); + InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax); + coneinsertshape->Z(11) = z; + coneinsertshape->Rmax(11) = rmax; + coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10); + + // SSD Cone Foams: two other Pcon's + TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4); + + conefoam1shape->Z(0) = coneinsertshape->GetZ(3); + conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3); + conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0); + + conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0); + conefoam1shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + conefoam1shape->GetRmax(1)); + conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta, + conefoam1shape->GetZ(1)); + + Double_t t = kConeThickness - 2*kCFThickness; + conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) - + (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta); + conefoam1shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + conefoam1shape->GetRmin(2)); + conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta, + conefoam1shape->GetZ(2)); + + conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2); + conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3); + conefoam1shape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + conefoam1shape->GetRmax(3)); + + TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4); + + conefoam2shape->Z(3) = coneinsertshape->GetZ(10); + conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10); + conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3); + + conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3); + conefoam2shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + conefoam2shape->GetRmin(2)); + conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta, + conefoam2shape->GetZ(2)); + + conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) + + (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta); + conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0); + conefoam2shape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + conefoam2shape->GetRmin(0)); + + conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0); + conefoam2shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + conefoam2shape->GetRmax(1)); + conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta, + conefoam2shape->GetZ(1)); + + // SSD Cone Holes: Pcon's + // A single hole volume gives an overlap with coneinsert, so + // three contiguous volumes are created: one to be put in coneinsert + // and two in the cone carbon fiber envelope + Double_t holePhi; + holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg(); + + TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4); + + coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight; + coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0); + coolingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + coolingholeshape->GetRmin(0)); + + coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0); + coolingholeshape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + coolingholeshape->GetRmax(1)); + coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta, + coolingholeshape->GetZ(1)); + + coolingholeshape->Rmin(2) = kCoolingHoleRmin; + coolingholeshape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + coolingholeshape->GetRmin(2)); + coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta, + coolingholeshape->GetZ(2)); + + coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2); + coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3); + coolingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + coolingholeshape->GetRmax(3)); + + TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight; + coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0); + coolinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta, + coolinghole2shape->GetRmin(0)); + + coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0); + coolinghole2shape->Z(1) = coolingholeshape->GetZ(0); + coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta, + coolinghole2shape->GetZ(1)); + + coolinghole2shape->Rmin(2) = kCoolingHoleRmin; + coolinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta, + coolinghole2shape->GetRmin(2)); + coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta, + coolinghole2shape->GetZ(2)); + + coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2); + coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3); + coolinghole2shape->Z(3) = coolingholeshape->GetZ(2); + + TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight; + coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0); + coolinghole3shape->Z(0) = coolingholeshape->GetZ(1); + + coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0); + coolinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta, + coolinghole3shape->GetRmax(1)); + coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta, + coolinghole3shape->GetZ(1)); + + coolinghole3shape->Rmin(2) = kCoolingHoleRmin; + coolinghole3shape->Z(2) = coolingholeshape->GetZ(3); + coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta, + coolinghole3shape->GetZ(2)); + + coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2); + coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3); + coolinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta, + coolinghole3shape->GetRmax(3)); + + // + holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg(); + + TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4); + + mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight; + mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0); + mountingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + mountingholeshape->GetRmin(0)); + + mountingholeshape->Rmin(1) = kMountingHoleRmin; + mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0); + mountingholeshape->Z(1) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta, + mountingholeshape->GetRmin(1)); + + mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1); + mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1); + mountingholeshape->Z(2) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + mountingholeshape->GetRmax(2)); + + mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2); + mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3); + mountingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta, + mountingholeshape->GetRmax(3)); + + TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight; + mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0); + mountinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta, + mountinghole2shape->GetRmin(0)); + + mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0); + mountinghole2shape->Z(1) = mountingholeshape->Z(0); + mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta, + mountinghole2shape->GetZ(1)); + + mountinghole2shape->Rmin(2) = kMountingHoleRmin; + mountinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta, + mountinghole2shape->GetRmin(2)); + mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta, + mountinghole2shape->GetZ(2)); + + mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2); + mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3); + mountinghole2shape->Z(3) = mountingholeshape->Z(1); + + TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4); + + mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight; + mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0); + mountinghole3shape->Z(0) = mountingholeshape->GetZ(2); + + mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0); + mountinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta, + mountinghole3shape->GetRmax(1)); + mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta, + mountinghole3shape->GetZ(1)); + + mountinghole3shape->Rmin(2) = kMountingHoleRmin; + mountinghole3shape->Z(2) = mountingholeshape->Z(3); + mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta, + mountinghole3shape->GetZ(2)); + + mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2); + mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3); + mountinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta, + mountinghole3shape->GetRmax(3)); + + // The Cable Hole is even more complicated, a Composite Shape + // is unavoidable here (gosh!) + TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12); + + for (Int_t i=0; i<12; i++) { + coneshapecopy->Rmin(i) = coneshape->GetRmin(i); + coneshapecopy->Rmax(i) = coneshape->GetRmax(i); + coneshapecopy->Z(i) = coneshape->GetZ(i); + } + + holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg(); + TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength, + kCableHoleRin, kCableHoleRout, + kCableHoleRin, kCableHoleRout, + -0.5*holePhi, 0.5*holePhi); + + TGeoCompositeShape *cableholeshape = new TGeoCompositeShape( + "SSDCableHoleShape", + "conecopy*chCS"); + + if(GetDebug(1)){ + chCS->InspectShape(); + cableholeshape->InspectShape(); + } + + // SSD Cone Wings: Tube and TubeSeg shapes + Double_t angleWideWing, angleWideWingThickness; + angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg(); + angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg(); + + TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax, + kWingHalfThick, + 0, angleWideWing); + + TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax, + kWingRmax-kCFThickness, + kWingHalfThick-kCFThickness, + angleWideWingThickness, + angleWideWing-angleWideWingThickness); + + // SDD support plate, SSD side (Mounting Bracket): a TubeSeg + TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax, + kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2); + + + // We have the shapes: now create the real volumes + + TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone", + coneshape,medSSDcf); + cfcone->SetVisibility(kTRUE); + cfcone->SetLineColor(4); // Blue + cfcone->SetLineWidth(1); + cfcone->SetFillColor(cfcone->GetLineColor()); + cfcone->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert", + coneinsertshape,medSSDste); + cfconeinsert->SetVisibility(kTRUE); + cfconeinsert->SetLineColor(2); // Red + cfconeinsert->SetLineWidth(1); + cfconeinsert->SetFillColor(cfconeinsert->GetLineColor()); + cfconeinsert->SetFillStyle(4050); // 50% transparent + + TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1", + conefoam1shape,medSSDroh); + cfconefoam1->SetVisibility(kTRUE); + cfconefoam1->SetLineColor(3); // Green + cfconefoam1->SetLineWidth(1); + cfconefoam1->SetFillColor(cfconefoam1->GetLineColor()); + cfconefoam1->SetFillStyle(4050); // 50% transparent + + TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2", + conefoam2shape,medSSDroh); + cfconefoam2->SetVisibility(kTRUE); + cfconefoam2->SetLineColor(3); // Green + cfconefoam2->SetLineWidth(1); + cfconefoam2->SetFillColor(cfconefoam2->GetLineColor()); + cfconefoam2->SetFillStyle(4050); // 50% transparent + + TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole", + coolingholeshape,medSSDair); + coolinghole->SetVisibility(kTRUE); + coolinghole->SetLineColor(5); // Yellow + coolinghole->SetLineWidth(1); + coolinghole->SetFillColor(coolinghole->GetLineColor()); + coolinghole->SetFillStyle(4090); // 90% transparent + + TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2", + coolinghole2shape,medSSDair); + coolinghole2->SetVisibility(kTRUE); + coolinghole2->SetLineColor(5); // Yellow + coolinghole2->SetLineWidth(1); + coolinghole2->SetFillColor(coolinghole2->GetLineColor()); + coolinghole2->SetFillStyle(4090); // 90% transparent + + TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3", + coolinghole3shape,medSSDair); + coolinghole3->SetVisibility(kTRUE); + coolinghole3->SetLineColor(5); // Yellow + coolinghole3->SetLineWidth(1); + coolinghole3->SetFillColor(coolinghole3->GetLineColor()); + coolinghole3->SetFillStyle(4090); // 90% transparent + + TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole", + mountingholeshape,medSSDair); + mountinghole->SetVisibility(kTRUE); + mountinghole->SetLineColor(5); // Yellow + mountinghole->SetLineWidth(1); + mountinghole->SetFillColor(mountinghole->GetLineColor()); + mountinghole->SetFillStyle(4090); // 90% transparent + + TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2", + mountinghole2shape,medSSDair); + mountinghole2->SetVisibility(kTRUE); + mountinghole2->SetLineColor(5); // Yellow + mountinghole2->SetLineWidth(1); + mountinghole2->SetFillColor(mountinghole2->GetLineColor()); + mountinghole2->SetFillStyle(4090); // 90% transparent + + TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3", + mountinghole3shape,medSSDair); + mountinghole3->SetVisibility(kTRUE); + mountinghole3->SetLineColor(5); // Yellow + mountinghole3->SetLineWidth(1); + mountinghole3->SetFillColor(mountinghole3->GetLineColor()); + mountinghole3->SetFillStyle(4090); // 90% transparent + + TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf); + wing->SetVisibility(kTRUE); + wing->SetLineColor(4); // Blue + wing->SetLineWidth(1); + wing->SetFillColor(wing->GetLineColor()); + wing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cablehole = new TGeoVolume("SSDCableHole", + cableholeshape,medSSDair); + cablehole->SetVisibility(kTRUE); + cablehole->SetLineColor(5); // Yellow + cablehole->SetLineWidth(1); + cablehole->SetFillColor(cablehole->GetLineColor()); + cablehole->SetFillStyle(4090); // 90% transparent + + TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert", + winginsertshape,medSSDste); + winginsert->SetVisibility(kTRUE); + winginsert->SetLineColor(2); // Red + winginsert->SetLineWidth(1); + winginsert->SetFillColor(winginsert->GetLineColor()); + winginsert->SetFillStyle(4050); // 50% transparent + + TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket", + bracketshape,medSSDal); + bracket->SetVisibility(kTRUE); + bracket->SetLineColor(6); // Purple + bracket->SetLineWidth(1); + bracket->SetFillColor(bracket->GetLineColor()); + bracket->SetFillStyle(4000); // 0% transparent + + // Mount up a cone + for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) { + Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi; + cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0)); + } + + for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) { + Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi; + cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0)); + } + + cfconeinsert->AddNode(cfconefoam1,1,0); + cfconeinsert->AddNode(cfconefoam2,1,0); + + cfcone->AddNode(cfconeinsert,1,0); + + for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) { + Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi; + cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0)); + cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0)); + cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0)); + } + + for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) { + Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi; + cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0)); + cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0)); + } + + wing->AddNode(winginsert,1,0); + + // Add all volumes in the Cone assembly + vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition)); + + for (Int_t i=0; i<4; i++) { + Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.; + vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick, + new TGeoRotation("",thetaW,180,0))); + } + + Double_t zBracket = kConeZPosition - coneshape->GetZ(9) + + 2*bracketshape->GetDz(); + for (Int_t i=0; i<3; i++) { + Double_t thetaB = 60 + 120.*i; + vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket, + new TGeoRotation("",thetaB,0,0))); + } + + // Finally put everything in the mother volume + moth->AddNode(cfcylinder,1,0); + + moth->AddNode(vC, 1, 0 ); + moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) ); + + // Some debugging if requested + if(GetDebug(1)){ + vC->PrintNodes(); + vC->InspectShape(); + } + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the cable trays which are outside the ITS support cones +// but still inside the TPC +// This is now a stearing routine, the actual work is done by three +// specialized methods to avoid a really huge unique method +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: 15 Nov 2009 Mario Sitta +// + + TraySupportsSideA(moth, mgr); + + ServicesCableSupportSPD(moth, mgr); + ServicesCableSupportSDD(moth, mgr); + ServicesCableSupportSSD(moth, mgr); + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the structure supporting the ITS cable trays on Side A +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: 14 Dec 2009 Mario Sitta +// Updated: 26 Feb 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Dimensions and positions of the A-Side Cable Tray Support Ring + // (0872/G/A/01) + const Double_t kSuppRingYTrans = 110.00 *fgkmm; + const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm; + const Double_t kSuppForwYTrans = 185.00 *fgkmm; + + const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm; + const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm; + const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm; + const Double_t kExtSuppRingBase = 491.50 *fgkmm; + const Double_t kExtSuppRingInward = 35.00 *fgkmm; + const Double_t kExtSuppRingRmax = 540.00 *fgkmm; + const Double_t kExtSuppRingRint1 = 465.00 *fgkmm; + const Double_t kExtSuppRingRint2 = 467.00 *fgkmm; + const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm; + const Double_t kExtSuppRingInWide = 100.00 *fgkmm; + const Double_t kExtSuppRingR7 = 7.00 *fgkmm; + const Double_t kExtSuppRingR5 = 5.00 *fgkmm; + const Double_t kExtSuppRingThick = 20.00 *fgkmm; + + const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad(); + const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad(); + const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad(); + const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad(); + const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed + + const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc + + const Double_t kIntSuppRingThick1 = 15.00 *fgkmm; + const Double_t kIntSuppRingThick2 = 13.00 *fgkmm; + const Double_t kIntSuppRingInward = 24.00 *fgkmm; + const Double_t kIntSuppRingThick = 20.00 *fgkmm; + + const Double_t kSuppCylHeight = 340.00 *fgkmm; + const Double_t kSuppCylRint = 475.00 *fgkmm; + const Double_t kSuppCylRext = 478.00 *fgkmm; + const Double_t kSuppCylDispl = 137.70 *fgkmm; + + const Double_t kSuppSpacerHeight = 30.00 *fgkmm; + const Double_t kSuppSpacerThick = 10.00 *fgkmm; + + const Double_t kSuppSpacerAngle = 15.00; // Degrees + + const Double_t kSuppForwRingRint1 = 500.00 *fgkmm; + const Double_t kSuppForwRingRint2 = 540.00 *fgkmm; + const Double_t kSuppForwRingRext = 560.00 *fgkmm; + const Double_t kSuppForwRingThikAll = 50.00 *fgkmm; + const Double_t kSuppForwRingThikInt = 20.00 *fgkmm; + + // (0872/G/B/01) + const Double_t kSuppForwConeRmin = 558.00 *fgkmm; + const Double_t kSuppForwConeRmax = 681.00 *fgkmm; + const Double_t kSuppForwConeLen1 = 318.00 *fgkmm; + const Double_t kSuppForwConeLen2 = 662.00 *fgkmm; + const Double_t kSuppForwConeThick = 3.00 *fgkmm; + + const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm; + const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm; + const Double_t kSuppBackRingHeight = 760.00 *fgkmm; + const Double_t kSuppBackRingRext = 760.00 *fgkmm; + const Double_t kSuppBackRingRint = 685.00 *fgkmm; +// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm; + const Double_t kSuppBackRingR10 = 10.00 *fgkmm; + const Double_t kSuppBackRingBase = 739.00 *fgkmm; + const Double_t kSuppBackRingThikAll = 50.00 *fgkmm; + const Double_t kSuppBackRingThick1 = 20.00 *fgkmm; + const Double_t kSuppBackRingThick2 = 20.00 *fgkmm; + +// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad(); + const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp. + const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad(); + const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad(); + + const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc + + // (0872/G/C/01) + const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm; + const Double_t kBackRodZTrans = 2420.00 *fgkmm; + + const Double_t kBackRodLength = 1160.00 *fgkmm; + const Double_t kBackRodThickLen = 20.00 *fgkmm; + const Double_t kBackRodDiameter = 20.00 *fgkmm; + + const Double_t kSuppRearRingRint = 360.00 *fgkmm; + const Double_t kSuppRearRingRext1 = 410.00 *fgkmm; + const Double_t kSuppRearRingRext2 = 414.00 *fgkmm; + const Double_t kSuppRearRingHeight = 397.00 *fgkmm; + const Double_t kSuppRearRingTopWide = 111.87 *fgkmm; + const Double_t kSuppRearRingBase = 451.50 *fgkmm; + const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm; + const Double_t kSuppRearRingSideHi = 52.00 *fgkmm; + const Double_t kSuppRearRingInside = 40.00 *fgkmm; + const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm; + const Double_t kSuppRearRingThick = 20.00 *fgkmm; + const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm; + const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm; + + const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad(); + const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad(); + + const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc + + + // Local variables + Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)]; + Double_t slp1, slp2, phi, xm, ym; + Double_t xloc, yloc, zloc, rmin, rmax, deltaR; + Int_t npoints; + + + // The whole support as an assembly + TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure"); + + + // First create all needed shapes + + // The External Ring (part of 0872/G/A/01): a really complex Xtru + TGeoXtru *extSuppRing = new TGeoXtru(2); + + // First the upper notch... + xprof[ 0] = kExtSuppRingSpace1; + yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov; + + slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng); + IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0., + xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym + + xprof[ 4] = xprof[5]; + yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng); + xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6)); + yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6)); + xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3)); + yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3)); + xprof[ 1] = xprof[4] - kExtSuppRingR5; + yprof[ 1] = yprof[4] - kExtSuppRingR5; + + Int_t indx = 5+kExtSuppRingNPtsArc; + // ...then the external arc, approximated with segments,... + xprof[indx] = kExtSuppRingBase; + yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax - + kExtSuppRingBase*kExtSuppRingBase); + Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax); + Double_t alphamax = TMath::Pi()/2 - + TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax); + + for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) { + Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc; + xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha); + yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha); + } + // ...and finally the interior profile + xprof[indx+1] = kExtSuppRingBase; + yprof[indx+1] = kSuppRingYTrans; + xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward; + yprof[indx+2] = yprof[indx+1]; + + phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng; + slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng); + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = kExtSuppRingRint2*TMath::Cos(phi); + ym = kExtSuppRingRint2*TMath::Sin(phi); + IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym, + xprof[indx+3], yprof[indx+3]); + + slp1 = slp2; + phi += kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = kExtSuppRingRint1*TMath::Cos(phi); + ym = kExtSuppRingRint1*TMath::Sin(phi); + IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym, + xprof[indx+4], yprof[indx+4]); + + slp1 = slp2; + phi += kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = kExtSuppRingRint2*TMath::Cos(phi); + ym = kExtSuppRingRint2*TMath::Sin(phi); + IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym, + xprof[indx+5], yprof[indx+5]); + + slp1 = slp2; + phi += kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = kExtSuppRingRint1*TMath::Cos(phi); + ym = kExtSuppRingRint1*TMath::Sin(phi); + IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym, + xprof[indx+6], yprof[indx+6]); + + xprof[indx+9] = kExtSuppRingInWide; + yprof[indx+9] = kExtSuppRingInnerHi; + xprof[indx+8] = xprof[indx+9] + + (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7; + yprof[indx+8] = yprof[indx+9] + + ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7; + xprof[indx+7] = xprof[indx+9] + + (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7; + yprof[indx+7] = yprof[indx+9] + + ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7; + // Gosh, we did the right side! now reflex on the left side + npoints = (sizeof(xprof)/sizeof(Double_t))/2; + for (Int_t jp = 0; jp < npoints; jp++) { + xprof[npoints+jp] = -xprof[npoints-1-jp]; + yprof[npoints+jp] = yprof[npoints-1-jp]; + } + // wow! now the actual Xtru + extSuppRing->DefinePolygon(2*npoints, xprof, yprof); + extSuppRing->DefineSection(0,0); + extSuppRing->DefineSection(1,kExtSuppRingThick); + + // The Internal Ring (part of 0872/G/A/01): another complex Xtru + TGeoXtru *intSuppRing = new TGeoXtru(2); + + // First the external profile... + npoints = 0; + + slp1 = 0; + phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi); + ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi); + IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov, + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + phi -= kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi); + ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi); + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + phi -= kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi); + ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi); + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + phi -= kExtSuppRingPartPhi; + slp2 = TMath::Tan(TMath::Pi()/2 + phi); + xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi); + ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi); + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward; + yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym, + xprof[npoints]); + npoints++; + + xprof[npoints] = xprof[npoints-1]; + yprof[npoints] = kSuppRingYTrans; + npoints++; + // ...and then the interior profile, which is identical to extSuppRing one + for (Int_t jp=0; jp < 8; jp++) { + xprof[npoints] = extSuppRing->GetX(17+jp); + yprof[npoints] = extSuppRing->GetY(17+jp); + npoints++; + } + // We did the right side! now reflex on the left side + for (Int_t jp = 0; jp < npoints; jp++) { + xprof[npoints+jp] = -xprof[npoints-1-jp]; + yprof[npoints+jp] = yprof[npoints-1-jp]; + } + // And now the actual Xtru + intSuppRing->DefinePolygon(2*npoints, xprof, yprof); + intSuppRing->DefineSection(0,0); + intSuppRing->DefineSection(1,kIntSuppRingThick); + + // The intermediate cylinder (0872/G/A/03): a TubeSeg + alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg(); + alphamax = 180 - alphamin; + TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext, + kSuppCylHeight/2, alphamin, alphamax); + + // The spacer (0872/G/A/03): a simple Xtru + TGeoXtru *suppSpacer = new TGeoXtru(2); + + xprof[0] = kSuppSpacerHeight; + yprof[0] = kSuppSpacerThick; + xprof[1] = xprof[0]; + yprof[1] = 0; + xprof[2] = 0; + yprof[2] = 0; + xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle); + yprof[3] = yprof[0]; + + suppSpacer->DefinePolygon(4, xprof, yprof); + suppSpacer->DefineSection(0,-kSuppCylHeight/2); + suppSpacer->DefineSection(1, kSuppCylHeight/2); + + // The forward ring (0872/G/B/02): a Pcon (slight oversimplification) + Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2; + alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg(); + alphamax = 180 - alphamin; + + TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4); + + forwardRing->DefineSection(0,0, + kSuppForwRingRint1,kSuppForwRingRext); + forwardRing->DefineSection(1,kSuppForwRingThikInt, + kSuppForwRingRint1,kSuppForwRingRext); + forwardRing->DefineSection(2,kSuppForwRingThikInt, + kSuppForwRingRint2,kSuppForwRingRext); + forwardRing->DefineSection(3,kSuppForwRingThikAll, + kSuppForwRingRint2,kSuppForwRingRext); + + // The forward cone (0872/G/B/03): a TGeoPcon + TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3); + + forwardCone->DefineSection(0,0, + kSuppForwConeRmin-kSuppForwConeThick, + kSuppForwConeRmin); + forwardCone->DefineSection(1,kSuppForwConeLen1, + kSuppForwConeRmin-kSuppForwConeThick, + kSuppForwConeRmin); + forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2, + kSuppForwConeRmax-kSuppForwConeThick, + kSuppForwConeRmax); + + // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru + TGeoXtru *firstSuppBackRing = new TGeoXtru(2); + + // First the external profile... (the arc is approximated with segments) + npoints = 0; + + xprof[npoints] = kSuppBackRingPlacTop; + yprof[npoints] = kSuppBackRingHeight; + npoints++; + + alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext); + alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext); + + xprof[npoints] = xprof[npoints-1]; + yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax); + npoints++; + + for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) { + Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc; + xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha); + yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha); + npoints++; + } + + xprof[npoints] = kSuppBackRingBase - + kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng); + yprof[npoints] = yprof[npoints-1]; + npoints++; + + xprof[npoints] = kSuppBackRingBase; + yprof[npoints] = kSuppForwYTrans; + npoints++; + // ...then the internal profile (the arc is approximated with segments) + alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint); + alphamax = TMath::Pi()/2; + + for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) { + Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc; + xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha); + yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha); + npoints++; + } + + xprof[npoints] = 0; + yprof[npoints] = kSuppBackRingRint; + npoints++; + // We did the right side! now reflex on the left side (except last point) + for (Int_t jp = 0; jp < npoints-1; jp++) { + xprof[npoints+jp] = -xprof[npoints-jp-2]; + yprof[npoints+jp] = yprof[npoints-jp-2]; + } + // And now the actual Xtru + firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof); + firstSuppBackRing->DefineSection(0,0); + firstSuppBackRing->DefineSection(1,kSuppBackRingThick1); + + // The second part of the Back Ring (part of 0872/G/B/01): a Pcon + // (slight oversimplification) + alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg(); + alphamax = 180 - alphamin; + + TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6); + + deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1); + rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1); + rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1); + secondSuppBackRing->DefineSection(0, 0, rmin, rmax); + + zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3)); + rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3); + rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1); + secondSuppBackRing->DefineSection(1, zloc, rmin, rmax); + + zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3)); + rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3); + rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1); + secondSuppBackRing->DefineSection(2, zloc, rmin, rmax); + + zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1)); + rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1); + rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1); + secondSuppBackRing->DefineSection(3, zloc, rmin, rmax); + + slp1 = TMath::Tan(kSuppBackRing2ndAng2); + slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1); + IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2, + slp2,kSuppBackRingThikAll,deltaR, + xm, ym); + + zloc = xm - kSuppBackRingThick1; + rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1); + rmax = rmin + deltaR; + secondSuppBackRing->DefineSection(4, zloc, rmin, rmax); + + zloc = kSuppBackRingThikAll - kSuppBackRingThick1; + rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1); + rmax = rmin + deltaR/2; + secondSuppBackRing->DefineSection(5, zloc, rmin, rmax); + + // The supporting rod: a Tube + TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2, + (kBackRodLength - kBackRodThickLen)/2); + + // The Back Ring (0872/G/C/01): another complex Xtru + TGeoXtru *suppRearRing = new TGeoXtru(2); + + // First the external profile... + npoints = 0; + + xprof[npoints] = kSuppRearRingTopWide; + yprof[npoints] = kSuppRearRingHeight; + npoints++; + + phi = kSuppRearRing1stAng; + slp1 = TMath::Tan(TMath::Pi() - phi); + phi += kSuppRearRingStepAng; + slp2 = TMath::Tan(TMath::Pi() - phi); + xm = kSuppRearRingRext2*TMath::Sin(phi); + ym = kSuppRearRingRext2*TMath::Cos(phi); + IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight, + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + phi += kSuppRearRingStepAng; + slp2 = TMath::Tan(TMath::Pi() - phi); + xm = kSuppRearRingRext1*TMath::Sin(phi); + ym = kSuppRearRingRext1*TMath::Cos(phi); + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + phi += kSuppRearRingStepAng; + slp2 = TMath::Tan(TMath::Pi() - phi); + xm = kSuppRearRingRext2*TMath::Sin(phi); + ym = kSuppRearRingRext2*TMath::Cos(phi); + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + slp1 = slp2; + slp2 = 0; + xm = kSuppRearRingBase; + ym = kSuppRearRingBaseHi + kSuppRearRingSideHi; + IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1], + slp2, xm, ym, + xprof[npoints], yprof[npoints]); + npoints++; + + xprof[npoints] = kSuppRearRingBase; + yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi; + npoints++; + xprof[npoints] = xprof[npoints - 1]; + yprof[npoints] = kSuppRearRingBaseHi; + npoints++; + xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside; + yprof[npoints] = yprof[npoints - 1]; + npoints++; + xprof[npoints] = xprof[npoints - 1]; + yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi; + npoints++; + // ...then the internal arc, approximated with segments,... + xprof[npoints] = kSuppRearRingRint; + yprof[npoints] = yprof[npoints - 1]; + + alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint); + alphamax = TMath::Pi()/2; + + for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) { + Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc; + xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha); + yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha); + } + + xprof[npoints+kSuppRearRingNPtsArc] = 0; + yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint; + // We did the right side! now reflex on the left side + Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc; + for (Int_t jp = 0; jp < nTotalPoints; jp++) { + xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp]; + yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp]; + } + + // And now the actual Xtru + suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof); + suppRearRing->DefineSection(0,0); + suppRearRing->DefineSection(1,kSuppRearRingThick); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$"); + + TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing", + extSuppRing, medAl); + + sideAExtSuppRing->SetVisibility(kTRUE); + sideAExtSuppRing->SetLineColor(kMagenta+1); + sideAExtSuppRing->SetLineWidth(1); + sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor()); + sideAExtSuppRing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing", + intSuppRing, medAl); + + sideAIntSuppRing->SetVisibility(kTRUE); + sideAIntSuppRing->SetLineColor(kMagenta+1); + sideAIntSuppRing->SetLineWidth(1); + sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor()); + sideAIntSuppRing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl", + interCylind, medAl); + + sideASuppCyl->SetVisibility(kTRUE); + sideASuppCyl->SetLineColor(kMagenta+1); + sideASuppCyl->SetLineWidth(1); + sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor()); + sideASuppCyl->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer", + suppSpacer, medAl); + + sideASuppSpacer->SetVisibility(kTRUE); + sideASuppSpacer->SetLineColor(kMagenta+1); + sideASuppSpacer->SetLineWidth(1); + sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor()); + sideASuppSpacer->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing", + forwardRing, medAl); + + sideASuppForwRing->SetVisibility(kTRUE); + sideASuppForwRing->SetLineColor(kMagenta+1); + sideASuppForwRing->SetLineWidth(1); + sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor()); + sideASuppForwRing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone", + forwardCone, medAl); + + sideASuppForwCone->SetVisibility(kTRUE); + sideASuppForwCone->SetLineColor(kMagenta+1); + sideASuppForwCone->SetLineWidth(1); + sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor()); + sideASuppForwCone->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing", + firstSuppBackRing, medAl); + + sideAFirstSuppBackRing->SetVisibility(kTRUE); + sideAFirstSuppBackRing->SetLineColor(kMagenta+1); + sideAFirstSuppBackRing->SetLineWidth(1); + sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor()); + sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing", + secondSuppBackRing, medAl); + + sideASecondSuppBackRing->SetVisibility(kTRUE); + sideASecondSuppBackRing->SetLineColor(kMagenta+1); + sideASecondSuppBackRing->SetLineWidth(1); + sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor()); + sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod", + suppRod, medAl); + + sideASuppRod->SetVisibility(kTRUE); + sideASuppRod->SetLineColor(kMagenta+1); + sideASuppRod->SetLineWidth(1); + sideASuppRod->SetFillColor(sideASuppRod->GetLineColor()); + sideASuppRod->SetFillStyle(4000); // 0% transparent + + TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing", + suppRearRing, medAl); + + sideASuppRearRing->SetVisibility(kTRUE); + sideASuppRearRing->SetLineColor(kMagenta+1); + sideASuppRearRing->SetLineWidth(1); + sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor()); + sideASuppRearRing->SetFillStyle(4000); // 0% transparent + + + // Now build up the support structure + zloc = kSuppRingZTrans; + trayASuppStruct->AddNode(sideAExtSuppRing, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideAExtSuppRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += kExtSuppRingThick; + trayASuppStruct->AddNode(sideAIntSuppRing, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideAIntSuppRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + xloc = kExtSuppRingBase - kIntSuppRingInward; + yloc = kSuppRingYTrans; + zloc += (kIntSuppRingThick + kSuppCylHeight/2); + trayASuppStruct->AddNode(sideASuppCyl, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideASuppCyl, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + trayASuppStruct->AddNode(sideASuppSpacer, 1, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",90+kSuppSpacerAngle,0,0))); + trayASuppStruct->AddNode(sideASuppSpacer, 2, + new TGeoCombiTrans(-xloc, yloc, zloc, + new TGeoRotation("",0,180,kSuppSpacerAngle-90))); + trayASuppStruct->AddNode(sideASuppSpacer, 3, + new TGeoCombiTrans( xloc,-yloc, zloc, + new TGeoRotation("",180,180,kSuppSpacerAngle-90))); + trayASuppStruct->AddNode(sideASuppSpacer, 4, + new TGeoCombiTrans(-xloc,-yloc, zloc, + new TGeoRotation("",270+kSuppSpacerAngle,0,0))); + + + zloc += kSuppCylHeight/2; + trayASuppStruct->AddNode(sideAIntSuppRing, 3, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideAIntSuppRing, 4, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += kIntSuppRingThick; + trayASuppStruct->AddNode(sideAExtSuppRing, 3, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideAExtSuppRing, 4, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += kExtSuppRingThick; + trayASuppStruct->AddNode(sideASuppForwRing, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideASuppForwRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += kSuppForwRingThikAll; + trayASuppStruct->AddNode(sideASuppForwCone, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideASuppForwCone, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += (kSuppForwConeLen1+kSuppForwConeLen2); + trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + zloc += kSuppBackRingThick1; + trayASuppStruct->AddNode(sideASecondSuppBackRing, 1, + new TGeoTranslation(0, 0, zloc) ); + trayASuppStruct->AddNode(sideASecondSuppBackRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + xloc = kSuppRearRingXRodHole; + yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole; + zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz(); + trayASuppStruct->AddNode(sideASuppRod, 1, + new TGeoTranslation( xloc, yloc, zloc) ); + trayASuppStruct->AddNode(sideASuppRod, 2, + new TGeoTranslation(-xloc, yloc, zloc) ); + trayASuppStruct->AddNode(sideASuppRod, 3, + new TGeoTranslation( xloc,-yloc, zloc) ); + trayASuppStruct->AddNode(sideASuppRod, 4, + new TGeoTranslation(-xloc,-yloc, zloc) ); + + zloc += suppRod->GetDz(); + trayASuppStruct->AddNode(sideASuppRearRing, 1, + new TGeoTranslation( 0, 0, zloc) ); + trayASuppStruct->AddNode(sideASuppRearRing, 2, + new TGeoCombiTrans( 0, 0, zloc, + new TGeoRotation("",180,0,0))); + + + // Finally put everything in the mother volume + moth->AddNode(trayASuppStruct,1,0); + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the all SPD cable trays which are outside the ITS support cones +// but still inside the TPC +// In order to avoid a huge monolithic routine, this method actually +// calls inner methods to create and assemble the various (macro)pieces +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 15 Nov 2009 Mario Sitta +// +// Technical data are taken from AutoCAD drawings and other (oral) +// information given by F.Tosello +// + + SPDCableTraysSideA(moth, mgr); + SPDCableTraysSideC(moth, mgr); + +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the all SDD cable trays which are outside the ITS support cones +// but still inside the TPC +// In order to avoid a huge monolithic routine, this method actually +// calls inner methods to create and assemble the various (macro)pieces +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: 14 Dec 2009 Mario Sitta +// + + SDDCableTraysSideA(moth, mgr); + SDDCableTraysSideC(moth, mgr); + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SSD cable trays which are outside the ITS support cones +// but still inside the TPC +// In order to avoid a huge monolithic routine, this method actually +// calls inner methods to create and assemble the various (macro)pieces +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: 15 Nov 2009 Mario Sitta +// + + SSDCableTraysSideA(moth, mgr); + SSDCableTraysSideC(moth, mgr); + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SPD cable trays which are outside the ITS support cones +// but still inside the TPC on Side A +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: 15 Feb 2010 Mario Sitta +// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes +// +// 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. +// + + // Overall position and rotation of the A-Side Cable Trays + // (parts of 0872/G/D) + const Double_t kTrayAR1Trans = 396.93 *fgkmm; + const Double_t kTrayAR2Trans = 413.93 *fgkmm; + const Double_t kTrayAZTrans = 1011.00 *fgkmm; + const Double_t kTrayAZRot = (180-169.5);// Degrees + const Double_t kTrayAFirstRotAng = 22.00; // Degrees + const Double_t kTrayASecondRotAng = 15.00; // Degrees + + const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardTrayTotalLen = 853.00 *fgkmm; + const Double_t kForwardTrayFirstLen = 435.00 *fgkmm; + const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardTrayThick = 2.00 *fgkmm; + + const Int_t kForwardSideNpoints = 6; + + const Double_t kExternalTrayLen = 1200.00 *fgkmm; + const Double_t kExternalTrayWide = kForwardTrayWide; + const Double_t kExternalTrayHigh = kForwardTraySecondHigh; + const Double_t kExternalTrayThick = kForwardTrayThick; + + const Double_t kCoolingTubeRmin = 5.00 *fgkmm; + const Double_t kCoolingTubeRmax = 6.00 *fgkmm; + + const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!! + const Double_t kLowVoltageCableSect = 3.412*fgkmm;//!!!ESTIMATED!!! + const Double_t kHiVoltageCableSect = 1.873*fgkmm;//!!!ESTIMATED!!! + + + // Local variables + Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints]; + Double_t xloc, yloc, zloc, alpharot; + + + // The two tray components as assemblies + TGeoVolumeAssembly *cableTrayAForw = + new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear"); + TGeoVolumeAssembly *cableTrayAExt = + new TGeoVolumeAssembly("ITSsupportSPDTrayAExt"); + + + // First create all needed shapes + + // The lower face of the forward tray: a BBox + TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2, + kForwardTrayThick/2, + kForwardTrayTotalLen/2); + + // The side face of the forward tray: a Xtru + TGeoXtru *forwTraySideFace = new TGeoXtru(2); + forwTraySideFace->SetName("ITSsuppSPDForwTraySide"); + + xprof[0] = 0; + yprof[0] = kForwardTrayThick; + xprof[1] = kForwardTrayTotalLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = kForwardTraySecondHigh - kForwardTrayThick; + xprof[3] = kForwardTrayFirstLen; + yprof[3] = yprof[2]; + xprof[4] = xprof[3]; + yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick; + xprof[5] = xprof[0]; + yprof[5] = yprof[4]; + + forwTraySideFace->DefinePolygon(6, xprof, yprof); + forwTraySideFace->DefineSection(0, 0); + forwTraySideFace->DefineSection(1, kForwardTrayThick); + + // The covers of the forward tray: two BBox's + TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2, + kForwardTrayThick/2, + kForwardTrayFirstLen/2); + + TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2, + kForwardTrayThick/2, + (kForwardTrayTotalLen - kForwardTrayFirstLen)/2); + + // Each small wing of the forward tray: a BBox + TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2, + (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2, + kForwardTrayThick/2); + + // The internal plane of the forward tray: a BBox + TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick, + kForwardTrayThick/2, + kForwardTrayTotalLen/2); + + // The internal wall of the forward tray: a BBox + TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2, + (kForwardTrayInterSpace-kForwardTrayThick)/2, + kForwardTrayTotalLen/2); + + // Each horizontal face of the external tray: a BBox + TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick, + kExternalTrayThick/2, + kExternalTrayLen/2); + + // Each vertical face of the external tray: a BBox + TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2, + kExternalTrayHigh/2, + kExternalTrayLen/2); + + // The internal wall of the external tray: a BBox + TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2, + (kForwardTrayInterSpace-kExternalTrayThick)/2, + kExternalTrayLen/2); + + // The cooling tube inside the forward tray: a Tube + Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick + - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot); + Double_t zlen = (zelong + kForwardTrayTotalLen)/2; + TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen); + + // The freon inside the forward tray tubes: a Tube + TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen); + + // The cooling tube inside the external tray: a Ctub + TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax, + kExternalTrayLen/2, 0, 360, + 0, SinD(kTrayAZRot),-CosD(kTrayAZRot), + 0, 0, 1); + + // The freon inside the forward tray tubes: a Tube + TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin, + kExternalTrayLen/2, 0, 360, + 0, SinD(kTrayAZRot),-CosD(kTrayAZRot), + 0, 0, 1); + + // The optical fibers inside the forward tray: a BBox + TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2, + kOpticalFibersSect/2, + kForwardTrayTotalLen/2); + + // The optical fibers inside the external tray: a Xtru + TGeoXtru *optFibsExt = new TGeoXtru(2); + optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs"); + + yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick + + 2*forwTrayWall->GetDY(); + xprof[0] = yprof[0]*TanD(kTrayAZRot); + xprof[1] = kExternalTrayLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kOpticalFibersSect; + yprof[3] = yprof[2]; + xprof[3] = yprof[2]*TanD(kTrayAZRot); + + optFibsExt->DefinePolygon(4, xprof, yprof); + optFibsExt->DefineSection(0, 0); + optFibsExt->DefineSection(1, kOpticalFibersSect); + + // The Low Voltage cables inside the forward tray: a BBox + TGeoBBox *lowCablesForw = new TGeoBBox(kLowVoltageCableSect/2, + kLowVoltageCableSect/2, + kForwardTrayTotalLen/2); + + // The Low Voltage inside the external tray: a Xtru + TGeoXtru *lowCablesExt = new TGeoXtru(2); + lowCablesExt->SetName("ITSsuppSPDExtTrayLowVoltage"); + + 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] + kLowVoltageCableSect; + yprof[3] = yprof[2]; + xprof[3] = yprof[2]*TanD(kTrayAZRot); + + lowCablesExt->DefinePolygon(4, xprof, yprof); + lowCablesExt->DefineSection(0, 0); + lowCablesExt->DefineSection(1, kLowVoltageCableSect); + + // The High Voltage cables inside the forward tray: a BBox + TGeoBBox *hiCablesForw = new TGeoBBox(kHiVoltageCableSect/2, + kHiVoltageCableSect/2, + kForwardTrayTotalLen/2); + + // The High Voltage inside the external tray: a Xtru + TGeoXtru *hiCablesExt = new TGeoXtru(2); + hiCablesExt->SetName("ITSsuppSPDExtTrayHiVoltage"); + + 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] + kHiVoltageCableSect; + yprof[3] = yprof[2]; + xprof[3] = yprof[2]*TanD(kTrayAZRot); + + hiCablesExt->DefinePolygon(4, xprof, yprof); + hiCablesExt->DefineSection(0, 0); + hiCablesExt->DefineSection(1, kHiVoltageCableSect); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$"); + TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$"); + TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED! + TGeoMedium *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$"); + TGeoMedium *medHVC = mgr->GetMedium("ITS_SPD_HICABLES$"); + + TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase", + forwTrayLowerFace, medAl); + + forwTrayABase->SetVisibility(kTRUE); + forwTrayABase->SetLineColor(6); // Purple + forwTrayABase->SetLineWidth(1); + forwTrayABase->SetFillColor(forwTrayABase->GetLineColor()); + forwTrayABase->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide", + forwTraySideFace, medAl); + + forwTrayASide->SetVisibility(kTRUE); + forwTrayASide->SetLineColor(6); // Purple + forwTrayASide->SetLineWidth(1); + forwTrayASide->SetFillColor(forwTrayASide->GetLineColor()); + forwTrayASide->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC", + forwTrayShortCover, medAl); + + forwTrayACoverShort->SetVisibility(kTRUE); + forwTrayACoverShort->SetLineColor(6); // Purple + forwTrayACoverShort->SetLineWidth(1); + forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor()); + forwTrayACoverShort->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC", + forwTrayLongCover, medAl); + + forwTrayACoverLong->SetVisibility(kTRUE); + forwTrayACoverLong->SetLineColor(6); // Purple + forwTrayACoverLong->SetLineWidth(1); + forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor()); + forwTrayACoverLong->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing", + forwTrayWing, medAl); + + forwTrayAWing->SetVisibility(kTRUE); + forwTrayAWing->SetLineColor(6); // Purple + forwTrayAWing->SetLineWidth(1); + forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor()); + forwTrayAWing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane", + forwTrayPlane, medAl); + + forwTrayAPlane->SetVisibility(kTRUE); + forwTrayAPlane->SetLineColor(6); // Purple + forwTrayAPlane->SetLineWidth(1); + forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor()); + forwTrayAPlane->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall", + forwTrayWall, medAl); + + forwTrayAWall->SetVisibility(kTRUE); + forwTrayAWall->SetLineColor(6); // Purple + forwTrayAWall->SetLineWidth(1); + forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor()); + forwTrayAWall->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace", + extTrayHorFace, medAl); + + extTrayAHorFace->SetVisibility(kTRUE); + extTrayAHorFace->SetLineColor(6); // Purple + extTrayAHorFace->SetLineWidth(1); + extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor()); + extTrayAHorFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace", + extTrayVerFace, medAl); + + extTrayAVerFace->SetVisibility(kTRUE); + extTrayAVerFace->SetLineColor(6); // Purple + extTrayAVerFace->SetLineWidth(1); + extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor()); + extTrayAVerFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall", + extTrayWall, medAl); + + extTrayAWall->SetVisibility(kTRUE); + extTrayAWall->SetLineColor(6); // Purple + extTrayAWall->SetLineWidth(1); + extTrayAWall->SetFillColor(extTrayAWall->GetLineColor()); + extTrayAWall->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube", + coolTubeForw, medIn); + + forwCoolTube->SetVisibility(kTRUE); + forwCoolTube->SetLineColor(kGray); // as in GeometrySPD + forwCoolTube->SetLineWidth(1); + forwCoolTube->SetFillColor(forwCoolTube->GetLineColor()); + forwCoolTube->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon", + freonTubeForw, medFreon); + + forwCoolFreon->SetVisibility(kTRUE); + forwCoolFreon->SetLineColor(kBlue); // Blue + forwCoolFreon->SetLineWidth(1); + forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor()); + forwCoolFreon->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube", + coolTubeExt, medIn); + + extCoolTube->SetVisibility(kTRUE); + extCoolTube->SetLineColor(kGray); // as in GeometrySPD + extCoolTube->SetLineWidth(1); + extCoolTube->SetFillColor(extCoolTube->GetLineColor()); + extCoolTube->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon", + freonTubeExt, medFreon); + + extCoolFreon->SetVisibility(kTRUE); + extCoolFreon->SetLineColor(kBlue); // Blue + extCoolFreon->SetLineWidth(1); + extCoolFreon->SetFillColor(extCoolFreon->GetLineColor()); + extCoolFreon->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs", + optFibsForw, medFibs); + + forwOptFibs->SetVisibility(kTRUE); + forwOptFibs->SetLineColor(kOrange); // Orange + forwOptFibs->SetLineWidth(1); + forwOptFibs->SetFillColor(forwOptFibs->GetLineColor()); + forwOptFibs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs", + optFibsExt, medFibs); + + extOptFibs->SetVisibility(kTRUE); + extOptFibs->SetLineColor(kOrange); // Orange + extOptFibs->SetLineWidth(1); + extOptFibs->SetFillColor(extOptFibs->GetLineColor()); + extOptFibs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwLowCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayLowCabs", + lowCablesForw, medLVC); + + forwLowCabs->SetVisibility(kTRUE); + forwLowCabs->SetLineColor(kRed); // Red + forwLowCabs->SetLineWidth(1); + forwLowCabs->SetFillColor(forwLowCabs->GetLineColor()); + forwLowCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extLowCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayLowCabs", + lowCablesExt, medLVC); + + extLowCabs->SetVisibility(kTRUE); + extLowCabs->SetLineColor(kRed); // Red + extLowCabs->SetLineWidth(1); + extLowCabs->SetFillColor(extLowCabs->GetLineColor()); + extLowCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwHiCabs = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabs", + hiCablesForw, medHVC); + + forwHiCabs->SetVisibility(kTRUE); + forwHiCabs->SetLineColor(kRed); // Red + forwHiCabs->SetLineWidth(1); + forwHiCabs->SetFillColor(forwHiCabs->GetLineColor()); + forwHiCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extHiCabs = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabs", + hiCablesExt, medHVC); + + extHiCabs->SetVisibility(kTRUE); + extHiCabs->SetLineColor(kRed); // Red + extHiCabs->SetLineWidth(1); + extHiCabs->SetFillColor(extHiCabs->GetLineColor()); + extHiCabs->SetFillStyle(4000); // 0% transparent + + + // Now build up the trays + yloc = forwTrayLowerFace->GetDY(); + zloc = forwTrayLowerFace->GetDZ(); + cableTrayAForw->AddNode(forwTrayABase, 1, + new TGeoTranslation(0, yloc, zloc)); + + xloc = kForwardTrayWide/2; + cableTrayAForw->AddNode(forwTrayASide, 1, + new TGeoCombiTrans( xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + cableTrayAForw->AddNode(forwTrayASide, 2, + new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0, + new TGeoRotation("",90,-90,-90))); + + yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY(); + zloc = forwTrayShortCover->GetDZ(); + cableTrayAForw->AddNode(forwTrayACoverShort, 1, + new TGeoTranslation(0, yloc, zloc)); + + yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY(); + zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ(); + cableTrayAForw->AddNode(forwTrayACoverLong, 1, + new TGeoTranslation(0, yloc, zloc)); + + xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX(); + yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY(); + zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ(); + cableTrayAForw->AddNode(forwTrayAWing, 1, + new TGeoTranslation( xloc, yloc, zloc)); + cableTrayAForw->AddNode(forwTrayAWing, 2, + new TGeoTranslation(-xloc, yloc, zloc)); + + yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY(); + zloc = forwTrayPlane->GetDZ(); + cableTrayAForw->AddNode(forwTrayAPlane, 1, + new TGeoTranslation(0, yloc, zloc)); + + yloc = kForwardTrayThick + forwTrayWall->GetDY(); + zloc = forwTrayWall->GetDZ(); + cableTrayAForw->AddNode(forwTrayAWall, 1, + new TGeoTranslation(0, yloc, zloc)); + + forwCoolTube->AddNode(forwCoolFreon, 1, 0); + + yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + + coolTubeForw->GetRmax(); + zloc = coolTubeForw->GetDz(); + cableTrayAForw->AddNode(forwCoolTube, 1, + new TGeoTranslation(0, yloc, zloc)); + + xloc = optFibsForw->GetDX() + coolTubeForw->GetRmax(); + yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + optFibsForw->GetDY(); + zloc = optFibsForw->GetDZ(); + cableTrayAForw->AddNode(forwOptFibs, 1, + new TGeoTranslation(xloc, yloc, zloc)); + + xloc = lowCablesForw->GetDX() + coolTubeForw->GetRmax(); + yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +lowCablesForw->GetDY(); + zloc = lowCablesForw->GetDZ(); + cableTrayAForw->AddNode(forwLowCabs, 1, + new TGeoTranslation(-xloc, yloc, zloc)); + + xloc = hiCablesForw->GetDX() + 2*lowCablesForw->GetDX() + + coolTubeForw->GetRmax(); + yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + hiCablesForw->GetDY(); + zloc = hiCablesForw->GetDZ(); + cableTrayAForw->AddNode(forwHiCabs, 1, + new TGeoTranslation(-xloc, yloc, zloc)); + + // To simplify following placement in MARS, origin is on top + yloc = -kExternalTrayHigh + kExternalTrayThick/2; + zloc = kExternalTrayLen/2; + cableTrayAExt->AddNode(extTrayAHorFace, 1, + new TGeoTranslation( 0, yloc, zloc)); + + xloc = kExternalTrayWide/2 - kExternalTrayThick/2; + yloc = -kExternalTrayHigh/2; + cableTrayAExt->AddNode(extTrayAVerFace, 1, + new TGeoTranslation( xloc, yloc, zloc)); + cableTrayAExt->AddNode(extTrayAVerFace, 2, + new TGeoTranslation(-xloc, yloc, zloc)); + + yloc = -kExternalTrayThick/2; + cableTrayAExt->AddNode(extTrayAHorFace, 2, + new TGeoTranslation( 0, yloc, zloc)); + + yloc = -kExternalTrayHigh + + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2; + cableTrayAExt->AddNode(extTrayAHorFace, 3, + new TGeoTranslation( 0, yloc, zloc)); + + yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY(); + cableTrayAExt->AddNode(extTrayAWall, 1, + new TGeoTranslation( 0, yloc, zloc)); + + extCoolTube->AddNode(extCoolFreon, 1, 0); + + yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY() + + coolTubeExt->GetRmax(); + zloc = coolTubeExt->GetDz(); + cableTrayAExt->AddNode(extCoolTube, 1, + new TGeoTranslation(0, yloc, zloc)); + + xloc = kOpticalFibersSect + coolTubeExt->GetRmax(); + cableTrayAExt->AddNode(extOptFibs, 1, + new TGeoCombiTrans( xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + + xloc = kLowVoltageCableSect + coolTubeExt->GetRmax(); + cableTrayAExt->AddNode(extLowCabs, 1, + new TGeoCombiTrans(-xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + + xloc = 2*kHiVoltageCableSect + kLowVoltageCableSect + coolTubeExt->GetRmax(); + cableTrayAExt->AddNode(extHiCabs, 1, + new TGeoCombiTrans(-xloc, 0, 0, + new TGeoRotation("",90,-90,-90))); + + + // Finally put everything in the mother volume + Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh; + + moth->AddNode(cableTrayAForw,1, + new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans)); + moth->AddNode(cableTrayAForw,2, + new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans, + new TGeoRotation("",180, 0, 0))); + + yloc = kTrayAR1Trans + kExternalTrayHigh; + zloc = kTrayAZTrans + kForwardTrayTotalLen; + moth->AddNode(cableTrayAExt,1, + new TGeoCombiTrans( 0, yloc, zloc, + new TGeoRotation("", 0,-kTrayAZRot, 0))); + moth->AddNode(cableTrayAExt,2, + new TGeoCombiTrans( 0,-yloc, zloc, + new TGeoRotation("",180,-kTrayAZRot, 0))); + + alpharot = kTrayAFirstRotAng + kTrayASecondRotAng; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,3, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,3, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,4, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,4, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,5, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,5, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,6, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,6, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,7, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,7, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,8, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,8, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,9, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,9, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayAR2Trans*SinD(alpharot); + yloc = kTrayAR2Trans*CosD(alpharot); + moth->AddNode(cableTrayAForw,10, + new TGeoCombiTrans( xloc, yloc, kTrayAZTrans, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,10, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SPD cable trays which are outside the ITS support cones +// but still inside the TPC on Side C +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Return: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 22 Apr 2010 Mario Sitta +// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes +// +// Technical data are taken from AutoCAD drawings and other (oral) +// information given by D.Elia +// + + // Dimensions and positions of the C-Side Cable Tray elements + const Int_t kNumTraysSideC = 10; + + const Double_t kTrayCHalfWide = 6.350 *fgkcm; + const Double_t kTrayCLength1 = 172.800 *fgkcm; + const Double_t kTrayCLength2 = 189.300 *fgkcm; + const Double_t kTrayCFirstLen = 435.000 *fgkmm; + const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kTrayCThick = 0.200 *fgkcm; + const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kTrayCFoldAngle = 5.000 *fgkDegree; + + const Double_t kCoolingTubeRmin = 5.000 *fgkmm; + const Double_t kCoolingTubeRmax = 6.000 *fgkmm; + const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!! + const Double_t kLowVoltageCableSect = 3.412 *fgkmm;//!!!ESTIMATED!!! + const Double_t kHiVoltageCableSect = 1.873 *fgkmm;//!!!ESTIMATED!!! + + // Overall position and rotation of the C-Side Cable Trays + const Double_t kTraySideCRPos = 45.300 *fgkcm; + const Double_t kTraySideCZPos = -102.400 *fgkcm; + const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] = + { 0.0, 41.0, -41.0, 76.0, -76.0}; + // From position of the other trays + + + // Local variables + Double_t xprof[8], yprof[8]; + Double_t xloc, yloc, zloc, delta, alpharot; + + + // The single C-Side Cable tray as an assembly + TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC"); + + // First create all needed shapes + + // The Cable Tray lower face: a Xtru + TGeoXtru *sideCHorFace = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kTrayCLength1; + yprof[1] = 0.; + xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle); + yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle); + xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle); + yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kTrayCThick , xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = kTrayCThick; + + delta = kTrayCHalfWide - kTrayCThick; + + sideCHorFace->DefinePolygon(6, xprof, yprof); + sideCHorFace->DefineSection(0,-delta); + sideCHorFace->DefineSection(1, delta); + + // The Cable Tray middle face: a Xtru + // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall) + TGeoXtru *sideCMidFace = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = kTrayCInterSpace + kTrayCThick; + xprof[1] = kTrayCLength1; + yprof[1] = yprof[0]; + xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle); + yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle); + xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle); + yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kTrayCThick , xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = yprof[0] + kTrayCThick; + + delta = kTrayCHalfWide - kTrayCThick; + + sideCMidFace->DefinePolygon(6, xprof, yprof); + sideCMidFace->DefineSection(0,-delta); + sideCMidFace->DefineSection(1, delta); + + // The Cable Tray lower face: a Xtru + TGeoXtru *sideCSideFace = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kTrayCLength1; + yprof[1] = 0.; + xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle); + yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle); + xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle); + yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kTrayCSecondHigh , xprof[4], yprof[4]); + xprof[5] = kTrayCFirstLen; + yprof[5] = kTrayCSecondHigh; + xprof[6] = xprof[5]; + yprof[6] = kTrayCFirstHigh; + xprof[7] = xprof[0]; + yprof[7] = yprof[6]; + + sideCSideFace->DefinePolygon(8, xprof, yprof); + sideCSideFace->DefineSection(0, 0); + sideCSideFace->DefineSection(1, kTrayCThick); + + // The short cover: a BBox + TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2, + kTrayCThick/2, + kTrayCHalfWide-kTrayCThick); + + // The long cover: a Xtru + TGeoXtru *sideCLongCover = new TGeoXtru(2); + + xprof[5] = sideCSideFace->GetX(5); + yprof[5] = sideCSideFace->GetY(5); + xprof[4] = sideCSideFace->GetX(4); + yprof[4] = sideCSideFace->GetY(4); + xprof[3] = sideCSideFace->GetX(3); + yprof[3] = sideCSideFace->GetY(3); + xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle); + yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle); + InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3], + -kTrayCThick , xprof[1], yprof[1]); + xprof[0] = xprof[5]; + yprof[0] = yprof[5] - kTrayCThick; + + delta = kTrayCHalfWide - kTrayCThick; + + sideCLongCover->DefinePolygon(6, xprof, yprof); + sideCLongCover->DefineSection(0,-delta); + sideCLongCover->DefineSection(1, delta); + + // The internal wall: a Xtru + TGeoXtru *intWall = new TGeoXtru(2); + + xprof[0] = sideCHorFace->GetX(5); + yprof[0] = sideCHorFace->GetY(5); + xprof[1] = sideCHorFace->GetX(4); + yprof[1] = sideCHorFace->GetY(4); + xprof[2] = sideCHorFace->GetX(3); + yprof[2] = sideCHorFace->GetY(3); + xprof[3] = sideCMidFace->GetX(2); + yprof[3] = sideCMidFace->GetY(2); + xprof[4] = sideCMidFace->GetX(1); + yprof[4] = sideCMidFace->GetY(1); + xprof[5] = sideCMidFace->GetX(0); + yprof[5] = sideCMidFace->GetY(0); + + intWall->DefinePolygon(6, xprof, yprof); + intWall->DefineSection(0,-kTrayCThick/2); + intWall->DefineSection(1, kTrayCThick/2); + + // The horizontal part of the cooling tube inside the tray: a Tube + delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5); + TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2); + + // The freon inside the horizontal part of the cooling tube: a Tube + TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2); + + // The inclined part of the cooling tube inside the tray: a Ctub + Double_t x3, y3, x4, y4; + x3 = sideCMidFace->GetX(3); + y3 = sideCMidFace->GetY(3); + x4 = sideCMidFace->GetX(4); + y4 = sideCMidFace->GetY(4); + delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))* + (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) + + (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))* + (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) ); + + TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360, + 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle), + 0, 0, 1); + + // The freon inside the inclined part of the cooling tube: a Ctub + TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360, + 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle), + 0, 0, 1); + + // The 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; + + optFibs->DefinePolygon(6, xprof, yprof); + optFibs->DefineSection(0, 0); + optFibs->DefineSection(1, kOpticalFibersSect); + + // The low voltage cables inside the tray: a Xtru + TGeoXtru *lowCables = new TGeoXtru(2); + + xprof[0] = sideCMidFace->GetX(5); + yprof[0] = sideCMidFace->GetY(5); + xprof[1] = sideCMidFace->GetX(4); + yprof[1] = sideCMidFace->GetY(4); + xprof[2] = sideCMidFace->GetX(3); + yprof[2] = sideCMidFace->GetY(3); + xprof[3] = xprof[2] - kLowVoltageCableSect*SinD(kTrayCFoldAngle); + yprof[3] = yprof[2] + kLowVoltageCableSect*CosD(kTrayCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kLowVoltageCableSect , xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = yprof[0] + kLowVoltageCableSect; + + lowCables->DefinePolygon(6, xprof, yprof); + lowCables->DefineSection(0, 0); + lowCables->DefineSection(1, kLowVoltageCableSect); + + // The high voltage cables inside the tray: a Xtru + TGeoXtru *hiCables = new TGeoXtru(2); + + xprof[0] = sideCMidFace->GetX(5); + yprof[0] = sideCMidFace->GetY(5); + xprof[1] = sideCMidFace->GetX(4); + yprof[1] = sideCMidFace->GetY(4); + xprof[2] = sideCMidFace->GetX(3); + yprof[2] = sideCMidFace->GetY(3); + xprof[3] = xprof[2] - kHiVoltageCableSect*SinD(kTrayCFoldAngle); + yprof[3] = yprof[2] + kHiVoltageCableSect*CosD(kTrayCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kHiVoltageCableSect , xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = yprof[0] + kHiVoltageCableSect; + + hiCables->DefinePolygon(6, xprof, yprof); + hiCables->DefineSection(0, 0); + hiCables->DefineSection(1, kHiVoltageCableSect); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$"); + TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$"); + TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!! + TGeoMedium *medLVC = mgr->GetMedium("ITS_SPD_LOWCABLES$"); + TGeoMedium *medHVC = mgr->GetMedium("ITS_SPD_HICABLES$"); + + TGeoVolume *traySideCHorFace = new TGeoVolume("ITSsuppSPDTraySideCHor", + sideCHorFace, medAl); + + traySideCHorFace->SetVisibility(kTRUE); + traySideCHorFace->SetLineColor(6); // Purple + traySideCHorFace->SetLineWidth(1); + traySideCHorFace->SetFillColor(traySideCHorFace->GetLineColor()); + traySideCHorFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid", + sideCMidFace, medAl); + + traySideCMidFace->SetVisibility(kTRUE); + traySideCMidFace->SetLineColor(6); // Purple + traySideCMidFace->SetLineWidth(1); + traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor()); + traySideCMidFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide", + sideCSideFace, medAl); + + traySideCSideFace->SetVisibility(kTRUE); + traySideCSideFace->SetLineColor(6); // Purple + traySideCSideFace->SetLineWidth(1); + traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor()); + traySideCSideFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov", + sideCShortCover, medAl); + + traySideCShortCover->SetVisibility(kTRUE); + traySideCShortCover->SetLineColor(6); // Purple + traySideCShortCover->SetLineWidth(1); + traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor()); + traySideCShortCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov", + sideCLongCover, medAl); + + traySideCLongCover->SetVisibility(kTRUE); + traySideCLongCover->SetLineColor(6); // Purple + traySideCLongCover->SetLineWidth(1); + traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor()); + traySideCLongCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *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); + + traySideCHorTube->SetVisibility(kTRUE); + traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD + traySideCHorTube->SetLineWidth(1); + traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor()); + traySideCHorTube->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon", + horFreon, medFr); + + traySideCHorFreon->SetVisibility(kTRUE); + traySideCHorFreon->SetLineColor(kBlue); // Blue + traySideCHorFreon->SetLineWidth(1); + traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor()); + traySideCHorFreon->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube", + incTube, medIn); + + traySideCIncTube->SetVisibility(kTRUE); + traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD + traySideCIncTube->SetLineWidth(1); + traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor()); + traySideCIncTube->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon", + incFreon, medFr); + + traySideCIncFreon->SetVisibility(kTRUE); + traySideCIncFreon->SetLineColor(kBlue); // Blue + traySideCIncFreon->SetLineWidth(1); + traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor()); + traySideCIncFreon->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs", + optFibs, medFibs); + + traySideCOptFibs->SetVisibility(kTRUE); + traySideCOptFibs->SetLineColor(kOrange); // Orange + traySideCOptFibs->SetLineWidth(1); + traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor()); + traySideCOptFibs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLowCabs = new TGeoVolume("ITSsuppSPDTraySideCLowCabs", + lowCables, medLVC); + + traySideCLowCabs->SetVisibility(kTRUE); + traySideCLowCabs->SetLineColor(kRed); // Red + traySideCLowCabs->SetLineWidth(1); + traySideCLowCabs->SetFillColor(traySideCLowCabs->GetLineColor()); + traySideCLowCabs->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCHiCabs = new TGeoVolume("ITSsuppSPDTraySideCHiCabs", + hiCables, medHVC); + + traySideCHiCabs->SetVisibility(kTRUE); + traySideCHiCabs->SetLineColor(kRed); // Red + traySideCHiCabs->SetLineWidth(1); + traySideCHiCabs->SetFillColor(traySideCHiCabs->GetLineColor()); + traySideCHiCabs->SetFillStyle(4000); // 0% transparent + + + // Now build up the trays + cableTrayC->AddNode(traySideCHorFace,1,0); + + cableTrayC->AddNode(traySideCMidFace,1,0); + + zloc = kTrayCHalfWide - kTrayCThick; + cableTrayC->AddNode(traySideCSideFace, 1, + new TGeoTranslation( 0, 0, zloc)); + zloc = -kTrayCHalfWide; + cableTrayC->AddNode(traySideCSideFace, 2, + new TGeoTranslation( 0, 0, zloc)); + + xloc = sideCShortCover->GetDX(); + yloc = kTrayCFirstHigh - sideCShortCover->GetDY(); + cableTrayC->AddNode(traySideCShortCover, 1, + new TGeoTranslation( xloc, yloc, 0)); + + cableTrayC->AddNode(traySideCLongCover,1,0); + + cableTrayC->AddNode(traySideCIntWall,1,0); + + traySideCHorTube->AddNode(traySideCHorFreon, 1, 0); + traySideCIncTube->AddNode(traySideCIncFreon, 1, 0); + + xloc = horTube->GetDz(); + yloc = sideCMidFace->GetY(5) + horTube->GetRmax(); + cableTrayC->AddNode(traySideCHorTube, 1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90.,-90.,90.))); + + xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle); + yloc = sideCMidFace->GetY(4) + incTube->GetRmax() + + (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp + cableTrayC->AddNode(traySideCIncTube, 1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.))); + + zloc = horTube->GetRmax(); + cableTrayC->AddNode(traySideCOptFibs, 1, + new TGeoTranslation( 0, 0, zloc)); + + zloc = kLowVoltageCableSect + horTube->GetRmax(); + cableTrayC->AddNode(traySideCLowCabs, 1, + new TGeoTranslation( 0, 0,-zloc)); + + zloc = kHiVoltageCableSect + kLowVoltageCableSect + horTube->GetRmax(); + cableTrayC->AddNode(traySideCHiCabs, 1, + new TGeoTranslation( 0, 0,-zloc)); + + + // Finally put everything in the mother volume + for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) { + alpharot = kTraySideCAlphaRot[jt]; + + xloc = kTraySideCRPos*SinD(alpharot); + yloc = kTraySideCRPos*CosD(alpharot); + moth->AddNode(cableTrayC,2*jt+1, + new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos, + new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle))); + alpharot += 180; + xloc = kTraySideCRPos*SinD(alpharot); + yloc = kTraySideCRPos*CosD(alpharot); + moth->AddNode(cableTrayC,2*jt+2, + new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos, + new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle))); + } + + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SDD cable trays which are outside the ITS support cones +// but still inside the TPC on Side A +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 5 Jan 2010 Mario Sitta +// Updated: 26 Feb 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Overall position and rotation of the A-Side Cable Trays + // (parts of 0872/G/D) + const Double_t kTrayARTrans = 408.35 *fgkmm; + const Double_t kTrayAZTrans = 1011.00 *fgkmm; + const Double_t kTrayAZToSupportRing = 435.00 *fgkmm; + const Double_t kExternTrayZTrans = 853.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 kForwardTrayTailHeight = 100.00 *fgkmm; // Computed + const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed + const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed + const Double_t kForwardCoverLength = 380.00 *fgkmm; + const Double_t kForwardCoverWide = 133.00 *fgkmm; + const Double_t kForwardCoverHeight = 10.00 *fgkmm; + const Double_t kForwardCoverThick = 1.00 *fgkmm; + + const Double_t kExternTrayTotalLen = 1200.00 *fgkmm; + const Double_t kExternTrayTotalHeight = 52.00 *fgkmm; + const Double_t kExternCoverLen = kExternTrayTotalLen; + const Double_t kExternCoverThick = 5.00 *fgkmm; + const Double_t kExternCoverSideThick = 3.00 *fgkmm; + + const Int_t kForwardTrayNpoints = 8; + + + // Local variables + Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints]; + Double_t xloc, yloc, zloc, alpharot; + + + // The whole tray as an assembly + TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA"); + + + // First create all needed shapes + + // The forward tray is very complex and deserves a dedicated method + TGeoVolumeAssembly *forwardTray = CreateSDDForwardTraySideA(mgr); + + // The forward cover: a Xtru + TGeoXtru *forwardCover = new TGeoXtru(2); + forwardCover->SetName("ITSsuppSDDForwCover"); + + xprof[0] = kForwardCoverWide/2; + yprof[0] = kForwardCoverHeight; + xprof[1] = xprof[0]; + yprof[1] = 0; + xprof[2] = xprof[1] - kForwardCoverThick; + yprof[2] = yprof[1]; + xprof[3] = xprof[2]; + yprof[3] = yprof[0] - kForwardCoverThick; + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 4; jp++) { + xprof[4+jp] = -xprof[3-jp]; + yprof[4+jp] = yprof[3-jp]; + } + + forwardCover->DefinePolygon(8, xprof, yprof); + forwardCover->DefineSection(0, 0); + forwardCover->DefineSection(1, kForwardCoverLength); + + // The external tray (as 0872/G/D/03): a Xtru + TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen, + kExternTrayTotalHeight); + + // The external covers: a Composite Shape + TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$"); + + TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover", + forwardCover, medAl); + + forwardTrayCover->SetVisibility(kTRUE); + forwardTrayCover->SetLineColor(kMagenta+1); // Purple + forwardTrayCover->SetLineWidth(1); + forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor()); + forwardTrayCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray", + externalTray, medAl); + + externalTraySDD->SetVisibility(kTRUE); + externalTraySDD->SetLineColor(6); // Purple + externalTraySDD->SetLineWidth(1); + externalTraySDD->SetFillColor(externalTraySDD->GetLineColor()); + externalTraySDD->SetFillStyle(4000); // 0% transparent + + TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover", + externCover, medAntic); + + externTrayCover->SetVisibility(kTRUE); + externTrayCover->SetLineColor(kMagenta+1); // Purple + externTrayCover->SetLineWidth(1); + externTrayCover->SetFillColor(externTrayCover->GetLineColor()); + externTrayCover->SetFillStyle(4000); // 0% transparent + + + // Now build up the tray + yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) + + kExternTrayTotalHeight + + kExternCoverSideThick - kForwardTrayTailHeight; + zloc = kTrayAZToSupportRing - kForwardCoverLength; + cableTrayA->AddNode(forwardTrayCover, 1, + new TGeoTranslation( 0, yloc, zloc) ); + + Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick + - kExternCoverYTrans; + + yloc = totalhi*(1 - 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)); + cableTrayA->AddNode(externTrayCover,1, + new TGeoCombiTrans( 0, yloc, zloc, + new TGeoRotation("", 0,-kTrayAZRot, 0) ) ); + + + // 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) ) ); + + alpharot += 180; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayA,2, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + + 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) ) ); + + alpharot += 180; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayA,4, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + + // To avoid putting an assembly inside another assembly, + // the forwardTray is put directly in the mother volume + Double_t rforw = kTrayARTrans + kExternTrayTotalHeight + + kExternCoverSideThick - + kForwardTrayTailHeight; + + alpharot = -kTrayAFirstRotAng; + xloc = rforw*SinD(alpharot); + yloc = rforw*CosD(alpharot); + zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength; + + moth->AddNode(forwardTray,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, + 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, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + + alpharot += 180; + xloc = rforw*SinD(alpharot); + yloc = rforw*CosD(alpharot); + moth->AddNode(forwardTray,4, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SDD cable trays which are outside the ITS support cones +// but still inside the TPC on Side C +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 17 Apr 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings and other (oral) +// information given by F.Tosello +// + + // Dimensions and positions of the C-Side Cable Tray elements + const Int_t kNumTraySideC = 4; + + const Double_t kSideCFoldAngle = 5.00 *fgkDegree; + + // Overall position and rotation of the C-Side Cable Trays + const Double_t kTraySideCRPos = 45.30 *fgkcm; + const Double_t kTraySideCZPos = -102.40 *fgkcm; + const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0, + /* from SSD tray position */ 180.-23.0, 180.+59.0}; + + + // Local variables +// Double_t xprof[12], yprof[12]; + Double_t xloc, yloc, alpharot, alphafold; + + + // The assembly holding the metallic structure + // We need four of them because the content is different + TGeoVolumeAssembly *trayStructure[kNumTraySideC]; + for (Int_t jt = 0; jt < kNumTraySideC; jt++) { + char name[20]; + sprintf(name,"ITSsupportSDDTrayC%d",jt); + trayStructure[jt] = CreateSDDSSDTraysSideC(name); + } + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + if (0==1) medAl->Print(); + + // Finally put everything in the mother volume + alphafold = kSideCFoldAngle; + + for (Int_t jt = 0; jt < kNumTraySideC; jt++) { + alpharot = kTraySideCAlphaRot[jt]; + xloc = kTraySideCRPos*SinD(alpharot); + yloc = kTraySideCRPos*CosD(alpharot); + moth->AddNode(trayStructure[jt],1, + new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos, + new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold))); + } + + + return; +} + + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SSD cable trays which are outside the ITS support cones +// but still inside the TPC on Side A +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 30 Dec 2009 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello and +// Ton van den Brink +// Cables and cooling tubes are approximated with proper materials and +// rectangular cross sections, always preserving the total material budget. +// + + // Dimensions and positions of the A-Side Cable Trays + // (parts of 0872/G/D) + const Double_t kTrayARTrans = 408.35 *fgkmm; + const Double_t kTrayAZTrans = 1011.00 *fgkmm; + const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kCoversYTrans = 2.00 *fgkmm; + const Double_t kTrayAZRot = (180-169.5);// Degrees + const Double_t kTrayAFirstRotAng = 22.00; // Degrees + const Double_t kTrayASecondRotAng = 15.00; // Degrees + + const Double_t kTrayTotalHeight = 52.00 *fgkmm; + const Double_t kTrayHeighToBend = 32.00 *fgkmm; + const Double_t kTrayWidth = 130.00 *fgkmm; + const Double_t kTrayThick = 2.00 *fgkmm; + + const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad(); + + const Double_t kForwardTrayTotalLen = 853.00 *fgkmm; + const Double_t kForwardTrayFirstLen = 350.00 *fgkmm; + const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm; + const Double_t kForwardCoverLen = 420.00 *fgkmm; + + const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!! + const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!! + const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!! + + const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm; + const Double_t kExternalCoverLen = kExternalTrayTotalLen; + const Double_t kExternalCoverThick = 5.00 *fgkmm; + + const Int_t kForwardTrayNpoints = 16; + + const Double_t kServicesWidth = 100.00 *fgkmm; + const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2 + const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2 + const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2 + const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2 + + + // Local variables + Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints]; + Double_t xloc, yloc, zloc, alpharot, totalhi; + + + // The two tray components as assemblies + TGeoVolumeAssembly *cableTrayAForw = + new TGeoVolumeAssembly("ITSsupportSSDTrayAForw"); + TGeoVolumeAssembly *cableTrayAExt = + new TGeoVolumeAssembly("ITSsupportSSDTrayAExt"); + + + // First create all needed shapes + + // The first part of the forward tray (part of 0872/G/D/07): a Xtru + TGeoXtru *forwTrayPart1 = new TGeoXtru(2); + + xprof[3] = kTrayWidth/2; + yprof[3] = kForwardTrayFirstHeight; + xprof[2] = xprof[3] - kTrayThick; + yprof[2] = yprof[3]; + xprof[4] = xprof[3]; + yprof[4] = kTrayTotalHeight - kTrayHeighToBend; + xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle); + yprof[5] = 0; + + InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5], + -kTrayThick, xprof[1], yprof[1]); + + xprof[6] = -xprof[5]; + yprof[6] = yprof[5]; + + InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6], + -kTrayThick, xprof[0], yprof[0]); + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 6; jp++) { + xprof[6+jp] = -xprof[5-jp]; + yprof[6+jp] = yprof[5-jp]; + } + + // And now the actual Xtru + forwTrayPart1->DefinePolygon(12, xprof, yprof); + forwTrayPart1->DefineSection(0, 0); + forwTrayPart1->DefineSection(1, kForwardTrayFirstLen); + + // The second part of the forward tray (part of 0872/G/D/07): a Xtru + TGeoXtru *forwTrayPart2 = + CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen, + kTrayTotalHeight); + + // The external tray (as 0872/G/D/03): a Xtru with same profile + TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen, + kTrayTotalHeight); + + // The side wall of the forward tray: a BBox + TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2, + kForwardSideHeight/2, + kForwardSideLength/2); + + // The side cover over the walls: a Xtru + TGeoXtru *forwSideCover = new TGeoXtru(2); + forwSideCover->SetName("ITSsuppSSDForwCover"); + + xprof[0] = kTrayWidth/2 + 2*kForwardSideThick; + yprof[0] = kForwardCoverHeight; + xprof[1] = xprof[0]; + yprof[1] = 0; + xprof[2] = xprof[1] - kForwardSideThick; + yprof[2] = yprof[1]; + xprof[3] = xprof[2]; + yprof[3] = yprof[0] - kForwardSideThick; + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 4; jp++) { + xprof[4+jp] = -xprof[3-jp]; + yprof[4+jp] = yprof[3-jp]; + } + + forwSideCover->DefinePolygon(8, xprof, yprof); + forwSideCover->DefineSection(0, 0); + forwSideCover->DefineSection(1, kForwardSideLength); + + // The forward and external covers: two Composite Shape's + TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen); + + TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen); + + // The cable copper inside the forward tray: a BBox + TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2, + kCopperHeight/2, + kForwardTrayTotalLen/2); + + // The cable copper inside the forward tray: a Xtru + TGeoXtru *extCopper = new TGeoXtru(2); + extCopper->SetName("ITSsuppSSDExtTrayCopper"); + + totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans + - kTrayThick; + + xprof[0] = -totalhi*TanD(kTrayAZRot); + yprof[0] = kTrayThick; + xprof[1] = kExternalTrayTotalLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kCopperHeight; + totalhi -= kCopperHeight; + xprof[3] = -totalhi*TanD(kTrayAZRot); + yprof[3] = yprof[2]; + + extCopper->DefinePolygon(4, xprof, yprof); + extCopper->DefineSection(0, 0); + extCopper->DefineSection(1, kServicesWidth); + + // The cable plastic inside the forward tray: a BBox + TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2, + kCablePlasticHeight/2, + kForwardTrayTotalLen/2); + + // The cable plastic inside the forward tray: a Xtru + TGeoXtru *extPlastic = new TGeoXtru(2); + extPlastic->SetName("ITSsuppSSDExtTrayPlastic"); + + totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans + - kTrayThick - kCopperHeight; + + xprof[0] = -totalhi*TanD(kTrayAZRot); + yprof[0] = kTrayThick; + xprof[1] = kExternalTrayTotalLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kCablePlasticHeight; + totalhi -= kCablePlasticHeight; + xprof[3] = -totalhi*TanD(kTrayAZRot); + yprof[3] = yprof[2]; + + extPlastic->DefinePolygon(4, xprof, yprof); + extPlastic->DefineSection(0, 0); + extPlastic->DefineSection(1, kServicesWidth); + + // The cooling water inside the forward tray: a BBox + TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2, + kCoolingWaterHeight/2, + kForwardTrayTotalLen/2); + + // The cooling water inside the forward tray: a Xtru + TGeoXtru *extWater = new TGeoXtru(2); + extWater->SetName("ITSsuppSSDExtTrayWater"); + + totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans + - kTrayThick - kCopperHeight - kCablePlasticHeight; + + xprof[0] = -totalhi*TanD(kTrayAZRot); + yprof[0] = kTrayThick; + xprof[1] = kExternalTrayTotalLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kCoolingWaterHeight; + totalhi -= kCoolingWaterHeight; + xprof[3] = -totalhi*TanD(kTrayAZRot); + yprof[3] = yprof[2]; + + extWater->DefinePolygon(4, xprof, yprof); + extWater->DefineSection(0, 0); + extWater->DefineSection(1, kServicesWidth); + + // The polyurethane inside the forward tray: a BBox + TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2, + kPoliUrethaneHeight/2, + kForwardTrayTotalLen/2); + + // The poliurethane inside the forward tray: a Xtru + TGeoXtru *extPUR = new TGeoXtru(2); + extPUR->SetName("ITSsuppSSDExtTrayPUR"); + + totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans + - kTrayThick - kCopperHeight - kCablePlasticHeight + - kCoolingWaterHeight; + + xprof[0] = -totalhi*TanD(kTrayAZRot); + yprof[0] = kTrayThick; + xprof[1] = kExternalTrayTotalLen; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kPoliUrethaneHeight; + totalhi -= kPoliUrethaneHeight; + xprof[3] = -totalhi*TanD(kTrayAZRot); + yprof[3] = yprof[2]; + + extPUR->DefinePolygon(4, xprof, yprof); + extPUR->DefineSection(0, 0); + extPUR->DefineSection(1, kServicesWidth); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$"); + TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$"); + TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$"); + TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$"); + TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$"); + + TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst", + forwTrayPart1, medAl); + + forwTrayFirst->SetVisibility(kTRUE); + forwTrayFirst->SetLineColor(6); // Purple + forwTrayFirst->SetLineWidth(1); + forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor()); + forwTrayFirst->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond", + forwTrayPart2, medAl); + + forwTraySecond->SetVisibility(kTRUE); + forwTraySecond->SetLineColor(6); // Purple + forwTraySecond->SetLineWidth(1); + forwTraySecond->SetFillColor(forwTraySecond->GetLineColor()); + forwTraySecond->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide", + forwSide, medAl); + + forwTraySide->SetVisibility(kTRUE); + forwTraySide->SetLineColor(6); // Purple + forwTraySide->SetLineWidth(1); + forwTraySide->SetFillColor(forwTraySide->GetLineColor()); + forwTraySide->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover", + forwSideCover, medAl); + + forwTraySideCover->SetVisibility(kTRUE); + forwTraySideCover->SetLineColor(6); // Purple + forwTraySideCover->SetLineWidth(1); + forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor()); + forwTraySideCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray", + externalTray, medAl); + + externalTraySSD->SetVisibility(kTRUE); + externalTraySSD->SetLineColor(6); // Purple + externalTraySSD->SetLineWidth(1); + externalTraySSD->SetFillColor(externalTraySSD->GetLineColor()); + externalTraySSD->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover", + forwardCover, medAntic); + + forwardTrayCover->SetVisibility(kTRUE); + forwardTrayCover->SetLineColor(kMagenta+1); // Purple + forwardTrayCover->SetLineWidth(1); + forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor()); + forwardTrayCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover", + externCover, medAntic); + + externTrayCover->SetVisibility(kTRUE); + externTrayCover->SetLineColor(kMagenta+1); // Purple + externTrayCover->SetLineWidth(1); + externTrayCover->SetFillColor(externTrayCover->GetLineColor()); + externTrayCover->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu", + forwCopper, medCu); + + forwCableCu->SetVisibility(kTRUE); + forwCableCu->SetLineColor(kRed); // Red + forwCableCu->SetLineWidth(1); + forwCableCu->SetFillColor(forwCableCu->GetLineColor()); + forwCableCu->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu", + extCopper, medCu); + + extCableCu->SetVisibility(kTRUE); + extCableCu->SetLineColor(kRed); // Red + extCableCu->SetLineWidth(1); + extCableCu->SetFillColor(extCableCu->GetLineColor()); + extCableCu->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP", + forwPlastic, medFEP); + + forwCableFEP->SetVisibility(kTRUE); + forwCableFEP->SetLineColor(kYellow); // Yellow + forwCableFEP->SetLineWidth(1); + forwCableFEP->SetFillColor(forwCableFEP->GetLineColor()); + forwCableFEP->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP", + extPlastic, medFEP); + + extCableFEP->SetVisibility(kTRUE); + extCableFEP->SetLineColor(kYellow); // Yellow + extCableFEP->SetLineWidth(1); + extCableFEP->SetFillColor(extCableFEP->GetLineColor()); + extCableFEP->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater", + forwWater, medH2O); + + forwTrayWater->SetVisibility(kTRUE); + forwTrayWater->SetLineColor(kBlue); // Blue + forwTrayWater->SetLineWidth(1); + forwTrayWater->SetFillColor(forwTrayWater->GetLineColor()); + forwTrayWater->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater", + extWater, medH2O); + + extTrayWater->SetVisibility(kTRUE); + extTrayWater->SetLineColor(kBlue); // Blue + extTrayWater->SetLineWidth(1); + extTrayWater->SetFillColor(extTrayWater->GetLineColor()); + extTrayWater->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr", + forwPUR, medPUR); + + forwPolyUr->SetVisibility(kTRUE); + forwPolyUr->SetLineColor(kGray); // Gray + forwPolyUr->SetLineWidth(1); + forwPolyUr->SetFillColor(forwPolyUr->GetLineColor()); + forwPolyUr->SetFillStyle(4000); // 0% transparent + + TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr", + extPUR, medPUR); + + extPolyUr->SetVisibility(kTRUE); + extPolyUr->SetLineColor(kGray); // Gray + extPolyUr->SetLineWidth(1); + extPolyUr->SetFillColor(extPolyUr->GetLineColor()); + extPolyUr->SetFillStyle(4000); // 0% transparent + + + // Now build up the tray + cableTrayAForw->AddNode(forwTrayFirst, 1, 0); + + cableTrayAForw->AddNode(forwTraySecond, 1, + new TGeoTranslation(0, 0, kForwardTrayFirstLen) ); + + xloc = kTrayWidth/2 + kForwardSideThick/2; + yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans; + zloc = kForwardSideLength/2; + cableTrayAForw->AddNode(forwTraySide,1, + new TGeoTranslation( xloc, yloc, zloc) ); + cableTrayAForw->AddNode(forwTraySide,2, + new TGeoTranslation(-xloc, yloc, zloc) ); + + yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans + - kForwardCoverHeight; + cableTrayAForw->AddNode(forwTraySideCover,1, + new TGeoTranslation(0, yloc, 0) ); + + yloc = kTrayTotalHeight - kCoversYTrans; + zloc = kForwardTrayTotalLen - kForwardCoverLen; + cableTrayAForw->AddNode(forwardTrayCover,1, + new TGeoTranslation(0, yloc, zloc) ); + + yloc = kTrayThick + forwCopper->GetDY(); + zloc = forwCopper->GetDZ(); + cableTrayAForw->AddNode(forwCableCu, 1, + new TGeoTranslation(0, yloc, zloc) ); + + yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY(); + zloc = forwPlastic->GetDZ(); + cableTrayAForw->AddNode(forwCableFEP, 1, + new TGeoTranslation(0, yloc, zloc) ); + + yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY(); + zloc = forwWater->GetDZ(); + cableTrayAForw->AddNode(forwTrayWater, 1, + new TGeoTranslation(0, yloc, zloc) ); + + yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + + kCoolingWaterHeight + forwPUR->GetDY(); + zloc = forwPUR->GetDZ(); + cableTrayAForw->AddNode(forwPolyUr, 1, + new TGeoTranslation(0, yloc, zloc) ); + + // To simplify following placement in MARS, origin is on top + totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans; + + yloc = -totalhi; + cableTrayAExt->AddNode(externalTraySSD, 1, + new TGeoTranslation(0, yloc, 0) ); + + yloc = -totalhi + kTrayTotalHeight - kCoversYTrans; + cableTrayAExt->AddNode(externTrayCover,1, + new TGeoTranslation(0, yloc, 0) ); + + xloc = extCopper->GetDZ(); + yloc = -totalhi; + cableTrayAExt->AddNode(extCableCu,1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90, 90, 90) ) ); + + xloc = extPlastic->GetDZ(); + yloc = -totalhi + kCopperHeight; + cableTrayAExt->AddNode(extCableFEP,1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90, 90, 90) ) ); + + xloc = extWater->GetDZ(); + yloc = -totalhi + kCopperHeight + kCablePlasticHeight; + cableTrayAExt->AddNode(extTrayWater,1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90, 90, 90) ) ); + + xloc = extPUR->GetDZ(); + yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight; + cableTrayAExt->AddNode(extPolyUr,1, + new TGeoCombiTrans( xloc, yloc, 0, + new TGeoRotation("",-90, 90, 90) ) ); + + + // Finally put everything in the mother volume + zloc = kTrayAZTrans; + Double_t zlocext = zloc + kForwardTrayTotalLen; + Double_t rExtTray = kTrayARTrans + kTrayTotalHeight; + + alpharot = kTrayAFirstRotAng; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayAForw,1, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,1, + new TGeoCombiTrans( xloc, yloc, zlocext, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayAForw,2, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,2, + new TGeoCombiTrans( xloc, yloc, zlocext, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayAForw,3, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,3, + new TGeoCombiTrans( xloc, yloc, zlocext, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + alpharot += 180; + xloc = kTrayARTrans*SinD(alpharot); + yloc = kTrayARTrans*CosD(alpharot); + moth->AddNode(cableTrayAForw,4, + new TGeoCombiTrans( xloc, yloc, zloc, + new TGeoRotation("",-alpharot,0,0) ) ); + xloc = rExtTray*SinD(alpharot); + yloc = rExtTray*CosD(alpharot); + moth->AddNode(cableTrayAExt,4, + new TGeoCombiTrans( xloc, yloc, zlocext, + new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) ); + + + return; +} + +//______________________________________________________________________ +void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth, + TGeoManager *mgr){ +// +// Creates the SSD cable trays which are outside the ITS support cones +// but still inside the TPC on Side C +// (part of this code is taken or anyway inspired to ServicesCableSupport +// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06) +// +// Input: +// moth : the TGeoVolume owing the volume structure +// mgr : the GeoManager (default gGeoManager) +// Output: +// +// Created: ??? Bjorn S. Nilsen +// Updated: 15 Apr 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings and other (oral) +// information given by F.Tosello +// + + // Dimensions and positions of the C-Side Cable Tray elements + const Int_t kNumTraySideC = 4; + + const Double_t kSideCFoldAngle = 5.00 *fgkDegree; + + const Double_t kServicesWidth = 100.00 *fgkmm; + const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2 + const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2 + const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2 + const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2 + + // Overall position and rotation of the C-Side Cable Trays + const Double_t kTraySideCRPos = 45.30 *fgkcm; + const Double_t kTraySideCZPos = -102.40 *fgkcm; + const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0, + /* from Patch panel position */ 180.+23.0, 180.-59.0}; + + + // Local variables + Double_t xprof[6], yprof[6]; + Double_t xloc, yloc, alpharot, alphafold; + + + // The assembly holding the metallic structure + TGeoVolumeAssembly *trayStructure = + CreateSDDSSDTraysSideC("ITSsupportSSDTrayC"); + + // The cable copper inside the tray: a Xtru + TGeoXtru *copper = new TGeoXtru(2); + copper->SetName("ITSsuppSSDTrayCCopper"); + + // Copper lies on the lower plate: get position of its points + TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape()); + xprof[0] = lowerplate->GetX(5); + yprof[0] = lowerplate->GetY(5); + xprof[1] = lowerplate->GetX(4); + yprof[1] = lowerplate->GetY(4); + xprof[2] = lowerplate->GetX(3); + yprof[2] = lowerplate->GetY(3); + xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle); + yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kCopperHeight , xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kCopperHeight; + + copper->DefinePolygon(6, xprof, yprof); + copper->DefineSection(0, -kServicesWidth/2); + copper->DefineSection(1, kServicesWidth/2); + + // The cable plastic inside the tray: a Xtru + TGeoXtru *plastic = new TGeoXtru(2); + plastic->SetName("ITSsuppSSDTrayCPlastic"); + + xprof[0] = copper->GetX(5); + yprof[0] = copper->GetY(5); + xprof[1] = copper->GetX(4); + yprof[1] = copper->GetY(4); + xprof[2] = copper->GetX(3); + yprof[2] = copper->GetY(3); + xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle); + yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kCablePlasticHeight , xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kCablePlasticHeight; + + plastic->DefinePolygon(6, xprof, yprof); + plastic->DefineSection(0, -kServicesWidth/2); + plastic->DefineSection(1, kServicesWidth/2); + + // The cooling water inside the tray: a Xtru + TGeoXtru *water = new TGeoXtru(2); + water->SetName("ITSsuppSSDTrayCWater"); + + xprof[0] = plastic->GetX(5); + yprof[0] = plastic->GetY(5); + xprof[1] = plastic->GetX(4); + yprof[1] = plastic->GetY(4); + xprof[2] = plastic->GetX(3); + yprof[2] = plastic->GetY(3); + xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle); + yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kCoolingWaterHeight , xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kCoolingWaterHeight; + + water->DefinePolygon(6, xprof, yprof); + water->DefineSection(0, -kServicesWidth/2); + water->DefineSection(1, kServicesWidth/2); + + // The poliurethane inside the tray: a Xtru + TGeoXtru *PUR = new TGeoXtru(2); + PUR->SetName("ITSsuppSSDTrayCPUR"); + + xprof[0] = water->GetX(5); + yprof[0] = water->GetY(5); + xprof[1] = water->GetX(4); + yprof[1] = water->GetY(4); + xprof[2] = water->GetX(3); + yprof[2] = water->GetY(3); + xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle); + yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kPoliUrethaneHeight , xprof[4], yprof[4]); + xprof[5] = xprof[0]; + yprof[5] = yprof[0] + kPoliUrethaneHeight; + + PUR->DefinePolygon(6, xprof, yprof); + PUR->DefineSection(0, -kServicesWidth/2); + PUR->DefineSection(1, kServicesWidth/2); + + + // We have all shapes: now create the real volumes + TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$"); + TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$"); + TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$"); + TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$"); + + TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu", + copper, medCu); + + copperCable->SetVisibility(kTRUE); + copperCable->SetLineColor(kRed); // Red + copperCable->SetLineWidth(1); + copperCable->SetFillColor(copperCable->GetLineColor()); + copperCable->SetFillStyle(4000); // 0% transparent + + TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP", + plastic, medFEP); + + cableFEP->SetVisibility(kTRUE); + cableFEP->SetLineColor(kYellow); // Yellow + cableFEP->SetLineWidth(1); + cableFEP->SetFillColor(cableFEP->GetLineColor()); + cableFEP->SetFillStyle(4000); // 0% transparent + + TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater", + water, medH2O); + + trayWater->SetVisibility(kTRUE); + trayWater->SetLineColor(kBlue); // Blue + trayWater->SetLineWidth(1); + trayWater->SetFillColor(trayWater->GetLineColor()); + trayWater->SetFillStyle(4000); // 0% transparent + + TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr", + PUR, medPUR); + + trayPolyUr->SetVisibility(kTRUE); + trayPolyUr->SetLineColor(kGray); // Gray + trayPolyUr->SetLineWidth(1); + trayPolyUr->SetFillColor(trayPolyUr->GetLineColor()); + trayPolyUr->SetFillStyle(4000); // 0% transparent + + + // Now fill in the tray + trayStructure->AddNode(copperCable,1,0); + trayStructure->AddNode(cableFEP,1,0); + trayStructure->AddNode(trayWater,1,0); + trayStructure->AddNode(trayPolyUr,1,0); + + + // Finally put everything in the mother volume + alphafold = kSideCFoldAngle; + + for (Int_t jt = 0; jt < kNumTraySideC; jt++) { + alpharot = kTraySideCAlphaRot[jt]; + xloc = kTraySideCRPos*SinD(alpharot); + yloc = kTraySideCRPos*CosD(alpharot); + moth->AddNode(trayStructure,jt+1, + new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos, + new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold))); + } + + + return; +} + +//______________________________________________________________________ +TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoManager *mgr){ +// +// Creates the forward SDD tray on Side A (0872/G/D/01) +// +// Input: +// mgr : the GeoManager (used only to get the proper material) +// +// Output: +// +// Return: a TGeoVolumeAssembly for the tray +// +// Created: 08 Jan 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01) + const Double_t kForwardTrayThick = 2.00 *fgkmm; + const Double_t kForwardTraySideLength = 823.00 *fgkmm; + const Double_t kForwardTrayTailLength = 212.00 *fgkmm; + const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm; + const Double_t kForwardTrayNotchLength = 47.20 *fgkmm; + const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm; + const Double_t kForwardTrayNotchDown = 10.00 *fgkmm; + const Double_t kForwardTraySide1Height = 39.00 *fgkmm; + const Double_t kForwardTraySide2Height = 26.00 *fgkmm; + const Double_t kForwardTraySide2Expand = 10.50 *fgkmm; + const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm; + const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm; + const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm; + const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm; + const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm; + const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm; + + const Int_t kForwardTraySideNpoints = 9; + + + // Local variables + Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints]; + Double_t ylen, zlen; + Double_t xloc, yloc, zloc; + + + // The tray has a very complex shape, so it is made by assembling + // different elements (with some small simplifications): the result + // is a TGeoAssembly returned to the caller + TGeoVolumeAssembly *forwardTray = new TGeoVolumeAssembly("ITSsuppSDDForwardTray"); + + // The tray base: a BBox + zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2; + TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide, + kForwardTrayThick/2, zlen); + + // The first part of the side wall: a Xtru + TGeoXtru *traySide1 = new TGeoXtru(2); + + xprof[0] = 0; + yprof[0] = kForwardTrayThick; + xprof[1] = kForwardTraySideLength-kForwardTrayTailLength; + yprof[1] = yprof[0]; + xprof[2] = kForwardTraySideLength; + yprof[2] = kForwardTraySide1Height + kForwardTrayThick; + xprof[3] = 0; + yprof[3] = yprof[2]; + + traySide1->DefinePolygon(4, xprof, yprof); + traySide1->DefineSection(0, 0); + traySide1->DefineSection(1, kForwardTrayThick); + + // The second part of the side wall: a Xtru + TGeoXtru *traySide2 = new TGeoXtru(2); + + xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick; + yprof[0] = traySide1->GetY(2); + xprof[1] = kForwardTrayBaseHalfWide; + yprof[1] = yprof[0]; + xprof[2] = xprof[1] + kForwardTraySide2Expand; + yprof[2] = yprof[1] + kForwardTraySide2Height; + xprof[3] = xprof[2] - kForwardTrayThick; + yprof[3] = yprof[2]; + + traySide2->DefinePolygon(4, xprof, yprof); + traySide2->DefineSection(0, 0); + traySide2->DefineSection(1, kForwardTraySideLength); + + // The third part of the side wall: a Xtru + TGeoXtru *traySide3 = new TGeoXtru(2); + + xprof[0] = 0; + yprof[0] = traySide2->GetY(2); + xprof[1] = kForwardTraySideLength; + yprof[1] = yprof[0]; + xprof[2] = xprof[1]; + yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick; + xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick; + yprof[3] = yprof[2]; + xprof[4] = xprof[3]; + yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick; + xprof[5] = xprof[4] - kForwardTraySide3HeadLen; + yprof[5] = yprof[4]; + xprof[6] = xprof[5]; + yprof[6] = yprof[5] - kForwardTrayNotchHeight; + xprof[7] = xprof[6] + kForwardTrayNotchLength; + yprof[7] = yprof[6]; + xprof[8] = xprof[7]; + yprof[8] = yprof[7] - kForwardTrayNotchDown; + + traySide3->DefinePolygon(9, xprof, yprof); + traySide3->DefineSection(0, 0); + traySide3->DefineSection(1, kForwardTrayThick); + + // The horizontal wing: a BBox + TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2, + kForwardTrayThick/2, + kForwardTraySide3TailLen/2); + + // The vertical wing: a BBox + ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2; + TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2, + ylen, kForwardTrayThick/2); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + + TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase", + trayBase, medAl); + + forwTrayBase->SetVisibility(kTRUE); + forwTrayBase->SetLineColor(6); // Purple + forwTrayBase->SetLineWidth(1); + forwTrayBase->SetFillColor(forwTrayBase->GetLineColor()); + forwTrayBase->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1", + traySide1, medAl); + + forwTraySide1->SetVisibility(kTRUE); + forwTraySide1->SetLineColor(6); // Purple + forwTraySide1->SetLineWidth(1); + forwTraySide1->SetFillColor(forwTraySide1->GetLineColor()); + forwTraySide1->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2", + traySide2, medAl); + + forwTraySide2->SetVisibility(kTRUE); + forwTraySide2->SetLineColor(6); // Purple + forwTraySide2->SetLineWidth(1); + forwTraySide2->SetFillColor(forwTraySide2->GetLineColor()); + forwTraySide2->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3", + traySide3, medAl); + + forwTraySide3->SetVisibility(kTRUE); + forwTraySide3->SetLineColor(6); // Purple + forwTraySide3->SetLineWidth(1); + forwTraySide3->SetFillColor(forwTraySide3->GetLineColor()); + forwTraySide3->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing", + trayHorWing, medAl); + + forwTrayHWing->SetVisibility(kTRUE); + forwTrayHWing->SetLineColor(6); // Purple + forwTrayHWing->SetLineWidth(1); + forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor()); + forwTrayHWing->SetFillStyle(4000); // 0% transparent + + TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing", + trayVertWing, medAl); + + forwTrayVWing->SetVisibility(kTRUE); + forwTrayVWing->SetLineColor(6); // Purple + forwTrayVWing->SetLineWidth(1); + forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor()); + forwTrayVWing->SetFillStyle(4000); // 0% transparent + + + // Now build up the tray + yloc = kForwardTrayThick/2; + zloc = zlen; + forwardTray->AddNode(forwTrayBase, 1, + new TGeoTranslation(0, yloc, zloc) ); + + xloc = kForwardTrayBaseHalfWide; + forwardTray->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, + new TGeoRotation("",90,-90,-90))); + + forwardTray->AddNode(forwTraySide2, 1, 0); + zloc = kForwardTraySideLength; + forwardTray->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, + new TGeoRotation("",90,-90,-90))); + xloc = -xloc + kForwardTrayThick; + forwardTray->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) ); + + 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) ); + + + return forwardTray; +} + +//______________________________________________________________________ +TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){ +// +// Creates the forward cover of the SDD and SSD cable trays on Side A +// (0872/G/D/02) +// +// Input: +// coverLen: the total length of the cover +// +// Output: +// +// Return: a TGeoCompositeShape for the cover +// +// Created: 03 Jan 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Dimensions and positions of the A-Side Cable Tray Forward Cover + // (0872/G/D/02) + const Double_t kForwardCoverWide = 130.00 *fgkmm; + const Double_t kForwardCoverSideWide = 10.00 *fgkmm; + const Double_t kForwardCoverHoleLen = 160.00 *fgkmm; + const Double_t kForwardCoverHoleWide = 90.00 *fgkmm; + const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm; + const Double_t kForwardCoverTotalThick = 5.00 *fgkmm; + const Double_t kForwardCoverSideThick = 3.00 *fgkmm; + const Double_t kForwardCoverInternThick = 2.00 *fgkmm; + + const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm; + + + // Local variables + Double_t xprof[16], yprof[16]; + Double_t yloc, zloc; + + + // The main shape: a Xtru + TGeoXtru *forwCoverMain = new TGeoXtru(2); + forwCoverMain->SetName("ITSsuppForwCoverMain"); + + xprof[0] = kForwardCoverWide/2; + yprof[0] = kForwardCoverTotalThick; + xprof[1] = xprof[0]; + yprof[1] = yprof[0] - kForwardCoverSideThick; + xprof[2] = xprof[1] - kForwardCoverSideWide; + yprof[2] = yprof[1]; + xprof[3] = xprof[2]; + yprof[3] = 0; + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 4; jp++) { + xprof[4+jp] = -xprof[3-jp]; + yprof[4+jp] = yprof[3-jp]; + } + + // And now the actual Xtru + forwCoverMain->DefinePolygon(8, xprof, yprof); + forwCoverMain->DefineSection(0, 0); + forwCoverMain->DefineSection(1, coverLen); + + // The hole: another Xtru (rounded corners approximated with segments) + TGeoXtru *forwCoverHole = new TGeoXtru(2); + forwCoverHole->SetName("ITSsuppForwCoverHole"); + + CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen, + kForwardCoverHoleR10 , xprof, yprof); + + // And now the actual Xtru + forwCoverHole->DefinePolygon(16, xprof, yprof); + forwCoverHole->DefineSection(0, 0); + forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick); + + // Now the proper rototranslation matrices for the two holes + yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix + zloc = kForwardCoverHoleZTrans; + TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + mf1->SetName("mf1"); + mf1->RegisterYourself(); + + zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen; + TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + mf2->SetName("mf2"); + mf2->RegisterYourself(); + + // Finally the actual cover shape + TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain", + "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2"); + + return cover; } + //______________________________________________________________________ -void AliITSv11GeometrySupport::SPDThermalSheald(TGeoVolume *moth){ - // Define the detail SPD Thermal Sheld geometry. - // Inputs: - // TGeo Volume *moth The mother volume to place this object. - // Outputs: - // none. - // Return: - // none. - // From ALICE-Thermal Screen (SPD) "Cylinder" file thermal-screen2_a3.ps - // Volumes sA1,sA2,sA3,sAh1,sAh2,sAh3, and b1,b2,b3,bh1,bh2,bh3; - // "CONE TRANSITION" file thermal-screen1_a3.ps Volumes sC1,sC2,sC3, - // sCh1,sCh2, sCh3; "FLANGE" file thermal-screen4_a3.ps Volumes d,sDs, - // sDw,sDws; and "HALF ASSEMBLY" file thermal-screen3_a3.ps. This object, - // both halfs, are incased inside of a single minimum sized mother - // volume called M, which is a union of two parts sM1 and 4 copies of sM2. - const Double_t ktscarbonFiberThA = 0.03*fgkmm; // - //const Double_t ktscarbonFiberThB = 0.10*fgkmm; // - const Double_t ktscLengthB = 50.0*fgkmm; // - const Double_t ktscLengthA = 900.0*fgkmm-2.0*ktscLengthB; // - const Double_t ktscLengthC = 290.0*fgkmm; // - const Double_t ktscLengthD = 15.0*fgkmm; // - const Double_t ktscAngle = 36.0*fgkDegree;//Rep. angle of cent. accordin - const Double_t ktscRoutA = 99.255*fgkmm; // Outer radii - const Double_t ktscRinA = 81.475*fgkmm; // Iner radii - const Double_t ktscRoutB = 99.955*fgkmm; // Outer radii - const Double_t ktscRinB = 80.775*fgkmm; // Iner radii - const Double_t ktscRoutCp = 390.0*fgkmm; // Outer radii - const Double_t ktscRinCp = 373.0*fgkmm; // Iner radii - Double_t ktscRoutC,ktscRinC; // values need to be calculated - const Double_t ktscRwingD = 492.5*fgkmm; // Outer radii - const Double_t ktscRoutD = 0.5*840.*fgkmm;// Outer radii - const Double_t ktscRinD = 373.0*fgkmm; // Iner radii - // angular wing - const Double_t ktscAngleDD = (60.*fgkmm/ktscRwingD)*fgkRadian; - // width of fill material - const Double_t ktscAngleDDs = ((60.*fgkmm-2.*ktscarbonFiberThA)/ - ktscRwingD)*fgkRadian; - const Double_t ktscAngleD0 = 45.*fgkDegree;//Strting angle of wing - const Double_t ktscoutSA = 24.372*fgkmm; // The other one Calculated - const Double_t ktscinLA = 31.674*fgkmm; // The ohter one Calculated - const Double_t ktscoutSB = 24.596*fgkmm; // The other one Calculated - const Double_t ktscinLB = 31.453*fgkmm; // The ohter one Calculated - const Double_t ktscoutSC = 148.831*fgkmm;// The other one Calculated - const Double_t ktscinLC = 90.915*fgkmm; // The ohter one Calculated - Int_t i,k; - Double_t th; - Double_t xo[7],yo[7],xi[7],yi[7]; - Double_t xbo[7],ybo[7],xbi[7],ybi[7]; - Double_t xco[7],yco[7],xci[7],yci[7]; - TGeoArb8 *sA1,*sA2,*sA3,*sAh1,*sAh2,*sAh3,*sB1,*sB2,*sB3,*sBh1,*sBh2,*sBh3; - TGeoArb8 *sC1,*sC2,*sC3,*sCh1,*sCh2,*sCh3; - TGeoPcon *sM1; - TGeoTube *sD,*sDs; - TGeoTubeSeg *sDw,*sDws,*sM2; - TGeoCompositeShape *sM; - TGeoRotation *rot; - TGeoTranslation *tranb,*tranbm,*tranc; - TGeoTranslation *tranITSspdShealdVVt0; - TGeoCombiTrans *rotITSspdShealdVVt1,*rotITSspdShealdVVt2; - TGeoCombiTrans *rotITSspdShealdVVt3; - TGeoMedium *medSPDcf = 0; // SPD support cone Carbon Fiber materal number. - TGeoMedium *medSPDfs = 0; // SPD support cone inserto stesalite 4411w. - TGeoMedium *medSPDfo = 0; // SPD support cone foam, Rohacell 50A. - TGeoMedium *medSPDss = 0; // SPD support cone screw material,Stainless - TGeoMedium *medSPDair = 0; // SPD support cone Air - //TGeoMedium *medSPDal = 0; // SPD support cone SDD mounting bracket Al - - ktscRoutC = TMath::Sqrt(ktscRoutCp*ktscRoutCp-0.25*ktscoutSC*ktscoutSC); - ktscRinC = TMath::Sqrt(ktscRinCp *ktscRinCp -0.25*ktscinLC *ktscinLC ); - sA1 = new TGeoArb8("ITS SPD Therm Screen Clyinder A1",0.5*ktscLengthA); - sA2 = new TGeoArb8("ITS SPD Therm Screen Clyinder A2",0.5*ktscLengthA); - sA3 = new TGeoArb8("ITS SPD Therm Screen Clyinder A3",0.5*ktscLengthA); - sAh1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah1",0.5*ktscLengthA); - sAh2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah2",0.5*ktscLengthA); - sAh3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah3",0.5*ktscLengthA); - sB1 = new TGeoArb8("ITS SPD Therm Screen Clyinder B1",0.5*ktscLengthB); - sB2 = new TGeoArb8("ITS SPD Therm Screen Clyinder B2",0.5*ktscLengthB); - sB3 = new TGeoArb8("ITS SPD Therm Screen Clyinder B3",0.5*ktscLengthB); - sBh1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh1",0.5*ktscLengthB); - sBh2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh2",0.5*ktscLengthB); - sBh3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh3",0.5*ktscLengthB); - sC1 = new TGeoArb8("ITS SPD Therm Screen Clyinder C1",0.5*ktscLengthC); - sC2 = new TGeoArb8("ITS SPD Therm Screen Clyinder C2",0.5*ktscLengthC); - sC3 = new TGeoArb8("ITS SPD Therm Screen Clyinder C3",0.5*ktscLengthC); - sCh1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch1",0.5*ktscLengthC); - sCh2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch2",0.5*ktscLengthC); - sCh3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch3",0.5*ktscLengthC); - sD = new TGeoTube("ITS SPD Therm Screen Flange D",ktscRinD,ktscRoutD, - 0.5*ktscLengthD); - sDs = new TGeoTube("ITS SPD Therm Screen Flange fill Ds", - ktscRinD+ktscarbonFiberThA,ktscRoutD-ktscarbonFiberThA, - 0.5*ktscLengthD); - sDw = new TGeoTubeSeg("ITS SPD Therm Screen Flange Wing Dw", - ktscRoutD,ktscRwingD ,0.5*ktscLengthD, - ktscAngleD0-0.5*ktscAngleDD, - ktscAngleD0+0.5*ktscAngleDD); - sDws = new TGeoTubeSeg("ITS SPD Therm Screen Flange Wing Fill Ds", - ktscRoutD,ktscRwingD-ktscarbonFiberThA, - 0.5*ktscLengthD,ktscAngleD0-0.5*ktscAngleDDs, - ktscAngleD0+0.5*ktscAngleDDs); - k = 0; - for(i=-1;i<2;i++){ - th = ((Double_t)(i+1))*ktscAngle*fgkDegree; - xo[k] = ktscRoutA*SinD(th) - 0.5*ktscoutSA*CosD(th); - yo[k] = ktscRoutA*CosD(th) + 0.5*ktscoutSA*SinD(th); - xi[k] = ktscRinA *SinD(th) - 0.5*ktscinLA *CosD(th); - yi[k] = ktscRinA *CosD(th) + 0.5*ktscinLA *SinD(th); - xbo[k] = ktscRoutB*SinD(th) - 0.5*ktscoutSB*CosD(th); - ybo[k] = ktscRoutB*CosD(th) + 0.5*ktscoutSB*SinD(th); - xbi[k] = ktscRinB *SinD(th) - 0.5*ktscinLB *CosD(th); - ybi[k] = ktscRinB *CosD(th) + 0.5*ktscinLB *SinD(th); - xco[k] = ktscRoutC*SinD(th) - 0.5*ktscoutSC*CosD(th); - yco[k] = ktscRoutC*CosD(th) + 0.5*ktscoutSC*SinD(th); - xci[k] = ktscRinC *SinD(th) - 0.5*ktscinLC *CosD(th); - yci[k] = ktscRinC *CosD(th) + 0.5*ktscinLC *SinD(th); - k++; - xo[k] = ktscRoutA*SinD(th) + 0.5*ktscoutSA*CosD(th); - yo[k] = ktscRoutA*CosD(th) - 0.5*ktscoutSA*SinD(th); - xi[k] = ktscRinA *SinD(th) + 0.5*ktscinLA *CosD(th); - yi[k] = ktscRinA *CosD(th) - 0.5*ktscinLA *SinD(th); - xbo[k] = ktscRoutB*SinD(th) + 0.5*ktscoutSB*CosD(th); - ybo[k] = ktscRoutB*CosD(th) - 0.5*ktscoutSB*SinD(th); - xbi[k] = ktscRinB *SinD(th) + 0.5*ktscinLB *CosD(th); - ybi[k] = ktscRinB *CosD(th) - 0.5*ktscinLB *SinD(th); - xco[k] = ktscRoutC*SinD(th) + 0.5*ktscoutSC*CosD(th); - yco[k] = ktscRoutC*CosD(th) - 0.5*ktscoutSC*SinD(th); - xci[k] = ktscRinC *SinD(th) + 0.5*ktscinLC *CosD(th); - yci[k] = ktscRinC *CosD(th) - 0.5*ktscinLC *SinD(th); - k++; - } // end for i - xo[6] = xo[5]; - yo[6] = 0.0; - xi[6] = xi[5]; - yi[6] = 0.0; - xbo[6] = xbo[5]; - ybo[6] = 0.0; - xbi[6] = xbi[5]; - ybi[6] = 0.0; - xco[6] = xco[5]; - yco[6] = 0.0; - xci[6] = xci[5]; - yci[6] = 0.0; - if(AliDebugLevel()){ - Info("SPDThermalSheald","i \t xo yo \t xi yi \t xbo " - "ybo \t xbi ybi \t xco yco \t xci yxi"); - for(i=0;i<7;i++){ - Info("SPDThermalSheald","%7d\t%7.4f,%7.4f\t%7.4f,%7.4f\t" - "%7.4f,%7.4f\t%7.4f,%7.4f\t%7.4f,%7.4f\t%7.4f,%7.4f",i, - xo[i],yo[i],xi[i],yi[i], - xbo[i],ybo[i],xbi[i],ybi[i], - xco[i],yco[i],xci[i],yci[i]); - } // end for i - } // end if AliDebugLevel() - //+++++++++++++++++++++++++ - sA1->SetVertex(0,xo[0],yo[0]); - sA1->SetVertex(1,xo[1],yo[1]); - sA1->SetVertex(2,xi[1],yi[1]); - sA1->SetVertex(3,xi[0],yi[0]); - // - sA2->SetVertex(0,xo[1],yo[1]); - sA2->SetVertex(1,xo[2],yo[2]); - sA2->SetVertex(2,xi[2],yi[2]); - sA2->SetVertex(3,xi[1],yi[1]); - // - sA3->SetVertex(0,xo[5],yo[5]); - sA3->SetVertex(1,xo[6],yo[6]); - sA3->SetVertex(2,xi[6],yi[6]); - sA3->SetVertex(3,xi[5],yi[5]); - //-------------------------- - sB1->SetVertex(0,xbo[0],ybo[0]); - sB1->SetVertex(1,xbo[1],ybo[1]); - sB1->SetVertex(2,xbi[1],ybi[1]); - sB1->SetVertex(3,xbi[0],ybi[0]); - // - sB2->SetVertex(0,xbo[1],ybo[1]); - sB2->SetVertex(1,xbo[2],ybo[2]); - sB2->SetVertex(2,xbi[2],ybi[2]); - sB2->SetVertex(3,xbi[1],ybi[1]); - // - sB3->SetVertex(0,xbo[5],ybo[5]); - sB3->SetVertex(1,xbo[6],ybo[6]); - sB3->SetVertex(2,xbi[6],ybi[6]); - sB3->SetVertex(3,xbi[5],ybi[5]); - //-------------------------- - sC1->SetVertex(0,xco[0],yco[0]); - sC1->SetVertex(1,xco[1],yco[1]); - sC1->SetVertex(2,xci[1],yci[1]); - sC1->SetVertex(3,xci[0],yci[0]); - // - sC2->SetVertex(0,xco[1],yco[1]); - sC2->SetVertex(1,xco[2],yco[2]); - sC2->SetVertex(2,xci[2],yci[2]); - sC2->SetVertex(3,xci[1],yci[1]); - // - sC3->SetVertex(0,xco[5],yco[5]); - sC3->SetVertex(1,xco[6],yco[6]); - sC3->SetVertex(2,xci[6],yci[6]); - sC3->SetVertex(3,xci[5],yci[5]); - // Defining the hole, filled with air - Double_t lp1,lc1,x,y,x7[3],y7[3]; - lp1 = (xo[0]-xi[0])/(yo[0]-yi[0]); - lc1 = xo[0]+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xo[0]-xi[0])+ - SQ(yo[0]-yi[0]))/(xo[0]-xi[0]); - y = ktscRoutA-2.*ktscarbonFiberThA; - x = lp1*(y-yo[0])+lc1; - sAh1->SetVertex(0,x,y); - sBh1->SetVertex(0,x,y); - sCh1->SetVertex(4,x,y); - y = ktscRinA+ktscarbonFiberThA; - x = lp1*(y-yo[0])+lc1; - sAh1->SetVertex(3,x,y); - sBh1->SetVertex(3,x,y); - x7[0] = x; y7[0] = y; // vortexing done after last point - //sCh1->SetVertex(7,x,y); - lp1 = (xo[1]-xi[1])/(yo[1]-yi[1]); - lc1 = xo[1]-0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xo[1]-xi[1])+ - SQ(yo[1]-yi[1]))/(xo[1]-xi[1]); - y = ktscRoutA-2.*ktscarbonFiberThA; - x = lp1*(y-yo[1])+lc1; - sAh1->SetVertex(1,x,y); - sBh1->SetVertex(1,x,y); - sCh1->SetVertex(5,x,y); - y = ktscRinA+ktscarbonFiberThA; - x = lp1*(y-yo[1])+lc1; - sAh1->SetVertex(2,x,y); - sBh1->SetVertex(2,x,y); - sCh1->SetVertex(6,x,y); - // - // The easist way to get the points for the hole in volume sA2 is to - // rotate it to the Y axis where the y coordinates are easier to know - // and then rotate it back. - Double_t xp,yp,xa,ya,xb,yb; - th = 0.5*ktscAngle; - xa = CosD(th)*xo[1]-SinD(th)*yo[1]; - ya = SinD(th)*xo[1]+CosD(th)*yo[1]; - xb = CosD(th)*xi[1]-SinD(th)*yi[1]; - yb = SinD(th)*xi[1]+CosD(th)*yi[1]; - lp1 = (xa-xb)/(ya-yb); - lc1 = xa+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb); - y = ya-ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sAh2->SetVertex(0,xp,yp); - sBh2->SetVertex(0,xp,yp); - sCh2->SetVertex(4,xp,yp); - y = yb+2.0*ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sAh2->SetVertex(3,xp,yp); - sBh2->SetVertex(3,xp,yp); - x7[1] = x; y7[1] = y; // vortexing done after last point - //sCh2->SetVertex(7,xp,yp); - xa = CosD(th)*xo[2]-SinD(th)*yo[2]; - ya = SinD(th)*xo[2]+CosD(th)*yo[2]; - xb = CosD(th)*xi[2]-SinD(th)*yi[2]; - yb = SinD(th)*xi[2]+CosD(th)*yi[2]; - lp1 = (xa-xb)/(ya-yb); - lc1 = xa-0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb); - y = ya-ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sAh2->SetVertex(1,xp,yp); - sBh2->SetVertex(1,xp,yp); - sCh2->SetVertex(5,xp,yp); - y = yb+2.0*ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sAh2->SetVertex(2,xp,yp); - sBh2->SetVertex(2,xp,yp); - sCh2->SetVertex(6,xp,yp); - // - lp1 = (yo[5]-yi[5])/(xo[5]-xi[5]); - lc1 = yo[5]+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(yo[5]-yi[5])+ - SQ(xo[5]-xi[5]))/(yo[5]-yi[5]); - x = xo[5]-ktscarbonFiberThA; - y = lp1*(x-xo[5])+lc1; - sAh3->SetVertex(0,x,y); - sBh3->SetVertex(0,x,y); - sCh3->SetVertex(4,x,y); - x = xi[5]+2.0*ktscarbonFiberThA; - y = lp1*(x-xo[5])+lc1; - sAh3->SetVertex(3,x,y); - sBh3->SetVertex(3,x,y); - x7[2] = x; y7[2] = y; // vortexing done after last point - //sCh3->SetVertex(7,x,y); - y = 2.0*ktscarbonFiberThA; - x = xo[5]-ktscarbonFiberThA; - sAh3->SetVertex(1,x,y); - sBh3->SetVertex(1,x,y); - sCh3->SetVertex(5,x,y); - y = 2.0*ktscarbonFiberThA; - x = xi[5]+2.0*ktscarbonFiberThA; - sAh3->SetVertex(2,x,y); - sBh3->SetVertex(2,x,y); - sCh3->SetVertex(6,x,y); - // - for(i=0;i<4;i++){ // define points at +dz - sA1->SetVertex(i+4,(sA1->GetVertices())[2*i],(sA1->GetVertices())[1+2*i]); - sA2->SetVertex(i+4,(sA2->GetVertices())[2*i],(sA2->GetVertices())[1+2*i]); - sA3->SetVertex(i+4,(sA3->GetVertices())[2*i],(sA3->GetVertices())[1+2*i]); - // - sB1->SetVertex(i+4,(sB1->GetVertices())[2*i],(sB1->GetVertices())[1+2*i]); - sB2->SetVertex(i+4,(sB2->GetVertices())[2*i],(sB2->GetVertices())[1+2*i]); - sB3->SetVertex(i+4,(sB3->GetVertices())[2*i],(sB3->GetVertices())[1+2*i]); - // C's are a cone which must match up with B's. - sC1->SetVertex(i+4,(sB1->GetVertices())[2*i],(sB1->GetVertices())[1+2*i]); - sC2->SetVertex(i+4,(sB2->GetVertices())[2*i],(sB2->GetVertices())[1+2*i]); - sC3->SetVertex(i+4,(sB3->GetVertices())[2*i],(sB3->GetVertices())[1+2*i]); - // - sAh1->SetVertex(i+4,(sAh1->GetVertices())[2*i], - (sAh1->GetVertices())[1+2*i]); - sAh2->SetVertex(i+4,(sAh2->GetVertices())[2*i], - (sAh2->GetVertices())[1+2*i]); - sAh3->SetVertex(i+4,(sAh3->GetVertices())[2*i], - (sAh3->GetVertices())[1+2*i]); - // - sBh1->SetVertex(i+4,(sBh1->GetVertices())[2*i], - (sBh1->GetVertices())[1+2*i]); - sBh2->SetVertex(i+4,(sBh2->GetVertices())[2*i], - (sBh2->GetVertices())[1+2*i]); - sBh3->SetVertex(i+4,(sBh3->GetVertices())[2*i], - (sBh3->GetVertices())[1+2*i]); - } // end for - // - lp1 = (xco[0]-xci[0])/(yco[0]-yci[0]); - lc1 = xco[0]+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xco[0]-xci[0])+ - SQ(yco[0]-yci[0]))/(xco[0]-xci[0]); - y = ktscRoutC-2.*ktscarbonFiberThA; - x = lp1*(y-yco[0])+lc1; - sCh1->SetVertex(0,x,y); - y = ktscRinC+ktscarbonFiberThA; - x = lp1*(y-yci[0])+lc1; - sCh1->SetVertex(2,x,y); - lp1 = (xco[1]-xci[1])/(yco[1]-yci[1]); - lc1 = xco[1]-0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xco[1]-xci[1])+ - SQ(yco[1]-yci[1]))/(xco[1]-xci[1]); - y = ktscRoutC-2.*ktscarbonFiberThA; - x = lp1*(y-yco[1])+lc1; - sCh1->SetVertex(1,x,y); - y = ktscRinC+ktscarbonFiberThA; - x = lp1*(y-yci[1])+lc1; - sCh1->SetVertex(3,x,y); - // - th = 0.5*ktscAngle; - xa = CosD(th)*xco[1]-SinD(th)*yco[1]; - ya = SinD(th)*xco[1]+CosD(th)*yco[1]; - xb = CosD(th)*xci[1]-SinD(th)*yci[1]; - yb = SinD(th)*xci[1]+CosD(th)*yci[1]; - lp1 = (xa-xb)/(ya-yb); - lc1 = xa+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb); - y = ya-ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - yp = ya-ktscarbonFiberThA; - xp = lp1*(y-ya)+lc1; - sCh2->SetVertex(0,xp,yp); - y = yb+2.0*ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sCh2->SetVertex(2,xp,yp); - xa = CosD(th)*xco[2]-SinD(th)*yco[2]; - ya = SinD(th)*xco[2]+CosD(th)*yco[2]; - xb = CosD(th)*xci[2]-SinD(th)*yci[2]; - yb = SinD(th)*xci[2]+CosD(th)*yci[2]; - lp1 = (xa-xb)/(ya-yb); - lc1 = xa-0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb); - y = ya-ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sCh2->SetVertex(1,xp,yp); - y = yb+2.0*ktscarbonFiberThA; - x = lp1*(y-ya)+lc1; - xp = CosD(-th)*x-SinD(-th)*y; - yp = SinD(-th)*x+CosD(-th)*y; - sCh2->SetVertex(3,xp,yp); - // - lp1 = (yco[5]-yci[5])/(xco[5]-xci[5]); - lc1 = yco[5]+0.5*ktscarbonFiberThA*TMath::Sqrt(SQ(yco[5]-yci[5])+ - SQ(xco[5]-xci[5]))/(yco[5]-yci[5]); - x = xco[5]-ktscarbonFiberThA; - y = lp1*(x-xco[5])+lc1; - sCh3->SetVertex(0,x,y); - x = xci[5]+2.0*ktscarbonFiberThA; - y = lp1*(x-xci[5])+lc1; - sCh3->SetVertex(2,x,y); - y = 2.0*ktscarbonFiberThA; - x = xco[5]-ktscarbonFiberThA; - sCh3->SetVertex(1,x,y); - y = 2.0*ktscarbonFiberThA; - x = xci[5]+2.0*ktscarbonFiberThA; - sCh3->SetVertex(3,x,y); - sCh1->SetVertex(7,x7[0],y7[0]); // 7th point most be done last ??? - sCh2->SetVertex(7,x7[1],y7[1]); // 7th point most be done last ??? - sCh3->SetVertex(7,x7[2],y7[2]); // 7th point most be done last ??? - // - // Define Minimal volume to inclose this SPD Thermal Sheald. - sM1 = new TGeoPcon("ITSspdShealdVV",0.0,360.0,9); - sM1->Z(0) = 0.5*ktscLengthA+ktscLengthB; - sM1->Rmin(0) = ktscRinB; - x = sB1->GetVertices()[0]; // [0][0] - y = sB1->GetVertices()[1]; // [0][1] - sM1->Rmax(0) = TMath::Sqrt(x*x+y*y); - sM1->Z(1) = sM1->GetZ(0)-ktscLengthB; - sM1->Rmin(1) = sM1->GetRmin(0); - sM1->Rmax(1) = sM1->GetRmax(0); - sM1->Z(2) = sM1->GetZ(1); - sM1->Rmin(2) = ktscRinA; - x = sA1->GetVertices()[0]; // [0]0] - y = sA1->GetVertices()[1]; // [0][1] - sM1->Rmax(2) = TMath::Sqrt(x*x+y*y); - sM1->Z(3) = -(sM1->GetZ(0)-ktscLengthB); - sM1->Rmin(3) = sM1->GetRmin(2); - sM1->Rmax(3) = sM1->GetRmax(2); - sM1->Z(4) = sM1->GetZ(3); - sM1->Rmin(4) = sM1->GetRmin(1); - sM1->Rmax(4) = sM1->GetRmax(1); - sM1->Z(5) = -(sM1->GetZ(0)); - sM1->Rmin(5) = sM1->GetRmin(0); - sM1->Rmax(5) = sM1->GetRmax(0); - sM1->Z(6) = sM1->GetZ(5) - ktscLengthC; - sM1->Rmin(6) = ktscRinC; - x = sC1->GetVertices()[0]; // [0][0] - y = sC1->GetVertices()[1]; // [0][1] - sM1->Rmax(6) = TMath::Sqrt(x*x+y*y); - sM1->Z(7) = sM1->GetZ(6); - sM1->Rmin(7) = sD->GetRmin(); - sM1->Rmax(7) = sD->GetRmax(); - sM1->Z(8) = sM1->Z(7) - ktscLengthD; - sM1->Rmin(8) = sM1->GetRmin(7); - sM1->Rmax(8) = sM1->GetRmax(7); - sM2 = new TGeoTubeSeg("ITSspdShealdWingVV", - sM1->GetRmax(8),sDw->GetRmax(),sDw->GetDz(), - sDw->GetPhi1(),sDw->GetPhi2()); - // - x = 0.5*(sM1->GetZ(8) + sM1->GetZ(7)); - tranITSspdShealdVVt0 = new TGeoTranslation("ITSspdShealdVVt0",0.0,0.0,x); - tranITSspdShealdVVt0->RegisterYourself(); - TGeoRotation rotz90("",0.0,0.0,90.0); // never registered. - rotITSspdShealdVVt1 = new TGeoCombiTrans(*tranITSspdShealdVVt0,rotz90); - rotITSspdShealdVVt1->SetName("ITSspdShealdVVt1"); - rotITSspdShealdVVt1->RegisterYourself(); - TGeoRotation rotz180("",0.0,0.0,180.0); // never registered - rotITSspdShealdVVt2 = new TGeoCombiTrans(*tranITSspdShealdVVt0,rotz180); - rotITSspdShealdVVt2->SetName("ITSspdShealdVVt2"); - rotITSspdShealdVVt2->RegisterYourself(); - TGeoRotation rotz270("",0.0,0.0,270.0); // never registered - rotITSspdShealdVVt3 = new TGeoCombiTrans(*tranITSspdShealdVVt0,rotz270); - rotITSspdShealdVVt3->SetName("ITSspdShealdVVt3"); - rotITSspdShealdVVt3->RegisterYourself(); - sM = new TGeoCompositeShape("ITS SPD Thermal sheald volume", - "(((ITSspdShealdVV+" - "ITSspdShealdWingVV:ITSspdShealdVVt0)+" - "ITSspdShealdWingVV:ITSspdShealdVVt1)+" - "ITSspdShealdWingVV:ITSspdShealdVVt2)+" - "ITSspdShealdWingVV:ITSspdShealdVVt3"); - // - if(AliDebugLevel()){ - tranITSspdShealdVVt0->Print(); - rotITSspdShealdVVt1->Print(); - rotITSspdShealdVVt2->Print(); - rotITSspdShealdVVt3->Print(); - sD->InspectShape(); - sDs->InspectShape(); - sDw->InspectShape(); - sDws->InspectShape(); - sA1->InspectShape(); - sAh1->InspectShape(); - sA2->InspectShape(); - sAh2->InspectShape(); - sA3->InspectShape(); - sAh3->InspectShape(); - sB1->InspectShape(); - sBh1->InspectShape(); - sB2->InspectShape(); - sBh2->InspectShape(); - sB3->InspectShape(); - sBh3->InspectShape(); - sC1->InspectShape(); - sCh1->InspectShape(); - sC2->InspectShape(); - sCh2->InspectShape(); - sC3->InspectShape(); - sCh3->InspectShape(); - sM1->InspectShape(); - sM2->InspectShape(); - sM->InspectShape(); - } // end if AliDebugLevel - // - TGeoManager *mgr = gGeoManager; - medSPDcf = mgr->GetMedium("ITSspdCarbonFiber"); - medSPDfs = mgr->GetMedium("ITSspdStaselite4411w"); - medSPDfo = mgr->GetMedium("ITSspdRohacell50A"); - medSPDss = mgr->GetMedium("ITSspdStainlessSteal"); - medSPDair= mgr->GetMedium("ITSspdAir"); - TGeoVolume *vA1,*vA2,*vA3,*vAh1,*vAh2,*vAh3; - TGeoVolume *vB1,*vB2,*vB3,*vBh1,*vBh2,*vBh3; - TGeoVolume *vC1,*vC2,*vC3,*vCh1,*vCh2,*vCh3; - TGeoVolume *vD,*vDs,*vDw,*vDws,*vM; - vM = new TGeoVolume("ITSspdThermalShealdMother",sM,medSPDair); - vM->SetVisibility(kTRUE); - vM->SetLineColor(7); // light Blue - vM->SetLineWidth(1); - vM->SetFillColor(vM->GetLineColor()); - vM->SetFillStyle(4090); // 90% transparent - moth->AddNode(vM,1,0); ///////////////////// Virtual Volume //////// - vA1 = new TGeoVolume("ITSspdCentCylA1CF",sA1,medSPDcf); - vA1->SetVisibility(kTRUE); - vA1->SetLineColor(4); - vA1->SetLineWidth(1); - vA2 = new TGeoVolume("ITSspdCentCylA2CF",sA2,medSPDcf); - vA2->SetVisibility(kTRUE); - vA2->SetLineColor(4); - vA2->SetLineWidth(1); - vA3 = new TGeoVolume("ITSspdCentCylA3CF",sA3,medSPDcf); - vA3->SetVisibility(kTRUE); - vA3->SetLineColor(4); - vA3->SetLineWidth(1); - vB1 = new TGeoVolume("ITSspdCentCylB1CF",sB1,medSPDcf); - vB1->SetVisibility(kTRUE); - vB1->SetLineColor(4); - vB1->SetLineWidth(1); - vB2 = new TGeoVolume("ITSspdCentCylB2CF",sB2,medSPDcf); - vB2->SetVisibility(kTRUE); - vB2->SetLineColor(4); - vB2->SetLineWidth(1); - vB3 = new TGeoVolume("ITSspdCentCylB3CF",sB3,medSPDcf); - vB3->SetVisibility(kTRUE); - vB3->SetLineColor(4); - vB3->SetLineWidth(1); - vC1 = new TGeoVolume("ITSspdCentCylC1CF",sC1,medSPDcf); - vC1->SetVisibility(kTRUE); - vC1->SetLineColor(4); - vC1->SetLineWidth(1); - vC2 = new TGeoVolume("ITSspdCentCylC2CF",sC2,medSPDcf); - vC2->SetVisibility(kTRUE); - vC2->SetLineColor(4); - vC2->SetLineWidth(1); - vC3 = new TGeoVolume("ITSspdCentCylC3CF",sC3,medSPDcf); - vC3->SetVisibility(kTRUE); - vC3->SetLineColor(4); - vC3->SetLineWidth(1); - vAh1 = new TGeoVolume("ITSspdCentCylA1AirA",sAh1,medSPDair); - vAh1->SetVisibility(kTRUE); - vAh1->SetLineColor(5); // Yellow - vAh1->SetFillColor(vAh1->GetLineColor()); - vAh1->SetFillStyle(4090); // 90% transparent - vAh2 = new TGeoVolume("ITSspdCentCylA2AirA",sAh2,medSPDair); - vAh2->SetVisibility(kTRUE); - vAh2->SetLineColor(5); // Yellow - vAh2->SetFillColor(vAh2->GetLineColor()); - vAh2->SetFillStyle(4090); // 90% transparent - vAh3 = new TGeoVolume("ITSspdCentCylA3AirA",sAh3,medSPDair); - vAh3->SetVisibility(kTRUE); - vAh3->SetLineColor(5); // Yellow - vAh3->SetFillColor(vAh3->GetLineColor()); - vAh3->SetFillStyle(4090); // 90% transparent - vBh1 = new TGeoVolume("ITSspdCentCylA1AirB",sBh1,medSPDair); - vBh1->SetVisibility(kTRUE); - vBh1->SetLineColor(5); // Yellow - vBh1->SetFillColor(vBh1->GetLineColor()); - vBh1->SetFillStyle(4090); // 90% transparent - vBh2 = new TGeoVolume("ITSspdCentCylA2AirB",sBh2,medSPDair); - vBh2->SetVisibility(kTRUE); - vBh2->SetLineColor(5); // Yellow - vBh2->SetFillColor(vBh2->GetLineColor()); - vBh2->SetFillStyle(4090); // 90% transparent - vBh3 = new TGeoVolume("ITSspdCentCylA3AirB",sBh3,medSPDair); - vBh3->SetVisibility(kTRUE); - vBh3->SetLineColor(5); // Yellow - vBh3->SetFillColor(vBh3->GetLineColor()); - vBh3->SetFillStyle(4090); // 90% transparent - vCh1 = new TGeoVolume("ITSspdCentCylA1AirC",sCh1,medSPDair); - vCh1->SetVisibility(kTRUE); - vCh1->SetLineColor(5); // Yellow - vCh1->SetFillColor(vCh1->GetLineColor()); - vCh1->SetFillStyle(4090); // 90% transparent - vCh2 = new TGeoVolume("ITSspdCentCylA2AirC",sCh2,medSPDair); - vCh2->SetVisibility(kTRUE); - vCh2->SetLineColor(5); // Yellow - vCh2->SetFillColor(vCh2->GetLineColor()); - vCh2->SetFillStyle(4090); // 90% transparent - vCh3 = new TGeoVolume("ITSspdCentCylA3AirC",sCh3,medSPDair); - vCh3->SetVisibility(kTRUE); - vCh3->SetLineColor(5); // Yellow - vCh3->SetFillColor(vCh3->GetLineColor()); - vCh3->SetFillStyle(4090); // 90% transparent - vD = new TGeoVolume("ITSspdCentCylA1CD",sD,medSPDcf); - vD->SetVisibility(kTRUE); - vD->SetLineColor(4); - vD->SetLineWidth(1); - vDw = new TGeoVolume("ITSspdCentCylA1CDw",sDw,medSPDcf); - vDw->SetVisibility(kTRUE); - vDw->SetLineColor(4); - vDw->SetLineWidth(1); - vDs = new TGeoVolume("ITSspdCentCylA1Dfill",sDs,medSPDfs); - vDs->SetVisibility(kTRUE); - vDs->SetLineColor(3); // Green - vDs->SetFillColor(vDs->GetLineColor()); - vDs->SetFillStyle(4010); // 10% transparent - vDws = new TGeoVolume("ITSspdCentCylA1DwingFill",sDws,medSPDfs); - vDws->SetVisibility(kTRUE); - vDws->SetLineColor(3); // Green - vDws->SetFillColor(vDws->GetLineColor()); - vDws->SetFillStyle(4010); // 10% transparent - // - vA1->AddNode(vAh1,1,0); - vA2->AddNode(vAh2,1,0); - vA3->AddNode(vAh3,1,0); - vB1->AddNode(vBh1,1,0); - vB2->AddNode(vBh2,1,0); - vB3->AddNode(vBh3,1,0); - vC1->AddNode(vCh1,1,0); - vC2->AddNode(vCh2,1,0); - vC3->AddNode(vCh3,1,0); - vD ->AddNode(vDs ,1,0); - vDw->AddNode(vDws,1,0); - // - vM->AddNode(vA1,1,0); - vM->AddNode(vA2,1,0); - vM->AddNode(vA3,1,0); - tranb = new TGeoTranslation("",0.0,0.0,0.5*(ktscLengthA+ktscLengthB)); - tranbm = new TGeoTranslation("",0.0,0.0,0.5*(-ktscLengthA-ktscLengthB)); - vM->AddNode(vB1,1,tranb); - vM->AddNode(vB2,1,tranb); - vM->AddNode(vB3,1,tranb); - vM->AddNode(vB1,2,tranbm); - vM->AddNode(vB2,2,tranbm); - vM->AddNode(vB3,2,tranbm); - // Muon side (rsB26) is at -Z. - tranc = new TGeoTranslation("",0.0,0.0, - 0.5*(-ktscLengthA-ktscLengthB-ktscLengthC)); - vM->AddNode(vC1,1,tranc); - vM->AddNode(vC2,1,tranc); - vM->AddNode(vC3,1,tranc); - vM->AddNode(vD,1,tranITSspdShealdVVt0); - vM->AddNode(vDw,1,tranITSspdShealdVVt0); - vM->AddNode(vDw,2,rotITSspdShealdVVt1); - vM->AddNode(vDw,3,rotITSspdShealdVVt2); - vM->AddNode(vDw,4,rotITSspdShealdVVt3); - k=2; - for(i=1;i<10;i++) { - th = ((Double_t)i)*ktscAngle*fgkDegree; - rot = new TGeoRotation("",0.0,0.0,th); - vM->AddNode(vA1,i+1,rot); - vM->AddNode(vB1,i+2,new TGeoCombiTrans(*tranb,*rot)); - vM->AddNode(vB1,i+12,new TGeoCombiTrans(*tranbm,*rot)); - vM->AddNode(vC1,i+1,new TGeoCombiTrans(*tranc,*rot)); - if(i!=0||i!=2||i!=7){ - vM->AddNode(vA2,k++,rot); - vM->AddNode(vB2,k++,new TGeoCombiTrans(*tranb,*rot)); - vM->AddNode(vB2,k++,new TGeoCombiTrans(*tranbm,*rot)); - vM->AddNode(vC2,k++,new TGeoCombiTrans(*tranc,*rot)); - } // end if - if(i==5) { - vM->AddNode(vA3,2,rot); - vM->AddNode(vB3,3,new TGeoCombiTrans(*tranb,*rot)); - vM->AddNode(vB3,4,new TGeoCombiTrans(*tranbm,*rot)); - vM->AddNode(vC3,2,new TGeoCombiTrans(*tranc,*rot)); - } // end if - } // end for i - rot = new TGeoRotation("",180.,0.0,0.0); - vM->AddNode(vA3,3,rot); - vM->AddNode(vB3,5,new TGeoCombiTrans(*tranb,*rot)); - vM->AddNode(vB3,6,new TGeoCombiTrans(*tranbm,*rot)); - vM->AddNode(vC3,3,new TGeoCombiTrans(*tranc,*rot)); - rot = new TGeoRotation("",180.,0.0,180.0); - vM->AddNode(vA3,4,rot); - vM->AddNode(vB3,7,new TGeoCombiTrans(*tranb,*rot)); - vM->AddNode(vB3,8,new TGeoCombiTrans(*tranbm,*rot)); - vM->AddNode(vC3,4,new TGeoCombiTrans(*tranc,*rot)); - if(AliDebugLevel()){ - vA1->PrintNodes(); - vAh1->PrintNodes(); - vA2->PrintNodes(); - vAh2->PrintNodes(); - vA3->PrintNodes(); - vAh3->PrintNodes(); - vB1->PrintNodes(); - vBh1->PrintNodes(); - vB2->PrintNodes(); - vBh2->PrintNodes(); - vB3->PrintNodes(); - vBh3->PrintNodes(); - vC1->PrintNodes(); - vCh1->PrintNodes(); - vC2->PrintNodes(); - vCh2->PrintNodes(); - vC3->PrintNodes(); - vCh3->PrintNodes(); - vD->PrintNodes(); - vDs->PrintNodes(); - vDw->PrintNodes(); - vDws->PrintNodes(); - vM->PrintNodes(); - } // end if +TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){ +// +// Creates the external cover of the SDD and SSD cable trays on Side A +// (0872/G/D/04) +// +// Input: +// coverLen: the total length of the cover +// +// Output: +// +// Return: a TGeoCompositeShape for the cover +// +// Created: 03 Jan 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Dimensions and positions of the A-Side Cable Tray External Cover + // (0872/G/D/04) + const Double_t kExternalCoverWide = 130.00 *fgkmm; + const Double_t kExternalCoverSideWide = 10.00 *fgkmm; + const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm; + const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm; + const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm; + const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm; + const Double_t kExternalCoverHoleWide = 90.00 *fgkmm; + const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm; + const Double_t kExternalCoverTotalThick = 5.00 *fgkmm; + const Double_t kExternalCoverSideThick = 3.00 *fgkmm; + const Double_t kExternalCoverInternThick = 2.00 *fgkmm; + + const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm; + const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm; + + + // Local variables + Double_t xprof[16], yprof[16]; + Double_t yloc, zloc; + + + // The main shape: a Xtru + TGeoXtru *externCoverMain = new TGeoXtru(2); + externCoverMain->SetName("ITSsuppExternCoverMain"); + + xprof[0] = kExternalCoverWide/2; + yprof[0] = kExternalCoverTotalThick; + xprof[1] = xprof[0]; + yprof[1] = yprof[0] - kExternalCoverSideThick; + xprof[2] = xprof[1] - kExternalCoverSideWide; + yprof[2] = yprof[1]; + xprof[3] = xprof[2]; + yprof[3] = 0; + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 4; jp++) { + xprof[4+jp] = -xprof[3-jp]; + yprof[4+jp] = yprof[3-jp]; + } + + // And now the actual Xtru + externCoverMain->DefinePolygon(8, xprof, yprof); + externCoverMain->DefineSection(0, 0); + externCoverMain->DefineSection(1, coverLen); + + // The first hole: a Xtru (rounded corners approximated with segments) + Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick; + + TGeoXtru *extCoverHole1 = new TGeoXtru(2); + extCoverHole1->SetName("ITSsuppExtCoverHole1"); + + CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1, + kExternalCoverHoleR10 , xprof, yprof); + + extCoverHole1->DefinePolygon(16, xprof, yprof); + extCoverHole1->DefineSection(0, 0); + extCoverHole1->DefineSection(1, holethick); + + // The second (and third) hole: another Xtru + TGeoXtru *extCoverHole2 = new TGeoXtru(2); + extCoverHole2->SetName("ITSsuppExtCoverHole2"); + + CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2, + kExternalCoverHoleR10 , xprof, yprof); + + extCoverHole2->DefinePolygon(16, xprof, yprof); + extCoverHole2->DefineSection(0, 0); + extCoverHole2->DefineSection(1, holethick); + + // The fourth hole: another Xtru + TGeoXtru *extCoverHole3 = new TGeoXtru(2); + extCoverHole3->SetName("ITSsuppExtCoverHole3"); + + CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3, + kExternalCoverHoleR10 , xprof, yprof); + + extCoverHole3->DefinePolygon(16, xprof, yprof); + extCoverHole3->DefineSection(0, 0); + extCoverHole3->DefineSection(1, holethick); + + // The fifth and last hole: another Xtru + TGeoXtru *extCoverHole4 = new TGeoXtru(2); + extCoverHole4->SetName("ITSsuppExtCoverHole4"); + + CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4, + kExternalCoverHoleR10 , xprof, yprof); + + extCoverHole4->DefinePolygon(16, xprof, yprof); + extCoverHole4->DefineSection(0, 0); + extCoverHole4->DefineSection(1, holethick); + + // Now the proper rototranslation matrices for the holes + yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01; + zloc = kExternalCoverHole1ZTrans; + TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + me1->SetName("me1"); + me1->RegisterYourself(); + + zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans); + TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + me2->SetName("me2"); + me2->RegisterYourself(); + + zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans); + TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + me3->SetName("me3"); + me3->RegisterYourself(); + + zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans); + TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + me4->SetName("me4"); + me4->RegisterYourself(); + + zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans); + TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc, + new TGeoRotation("", 0, 90, 0) ); + me5->SetName("me5"); + me5->RegisterYourself(); + + // Finally the actual cover shape + TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain", + "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5"); + + return cover; } + //______________________________________________________________________ -void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth){ - // Define the detail SDD support cone geometry. - // Inputs: - // TGeo Volume *moth The mother volume to place this object. - // Outputs: - // none. - // Return: - // none. - // - // From Cilindro Centrale - Lavorazioni, ALR 0816/1 04/08/03 File - // name SDD/Cilindro.hpgl - const Double_t ktsLength = 790.0*fgkmm; // Thermal Sheeld length - const Double_t ktsInsertoLength= 15.0*fgkmm; // ???? - const Double_t ktsOuterR = 0.5*(220.+10.)*fgkmm; // ???? - const Double_t ktsInnerR = 0.5*(220.-10.)*fgkmm; // ???? - const Double_t ktscarbonFiberth= 0.02*fgkmm; // ???? - const Double_t ktsBoltDiameter = 6.0*fgkmm; // M6 screw - const Double_t ktsBoltDepth = 6.0*fgkmm; // in volume sC - const Double_t ktsBoltRadius = 0.5*220.*fgkmm; // Radius in volume sC - const Double_t ktsBoltAngle0 = 0.0*fgkDegree; // Angle in volume sC - const Double_t ktsBoltdAngle = 30.0*fgkDegree; // Angle in Volume sC - Double_t x,y,z,t,t0,rmin,rmax; - Int_t i,n; - TGeoTube *sA,*sB,*sC,*sD; - TGeoTranslation *tran; - TGeoRotation *rot; - TGeoCombiTrans *rotran; - TGeoMedium *medSDDcf,*medSDDfs,*medSDDfo,*medSDDss; - - sA = new TGeoTube("ITS SDD Central Cylinder",ktsInnerR,ktsOuterR, - 0.5*ktsLength); - sB = new TGeoTube("ITS SDD CC Foam",ktsInnerR+ktscarbonFiberth, - ktsOuterR-ktscarbonFiberth, - 0.5*(ktsLength-2.0*ktsInsertoLength)); - sC = new TGeoTube("ITS SDD CC Inserto",ktsInnerR+ktscarbonFiberth, - ktsOuterR-ktscarbonFiberth,0.5*ktsLength); - sD = new TGeoTube("ITS SDD CC M6 bolt end",0.0,0.5*ktsBoltDiameter, - 0.5*ktsBoltDepth); - if(AliDebugLevel()){ - sA->InspectShape(); - sB->InspectShape(); - sC->InspectShape(); - sD->InspectShape(); - } // end if AliDebugLevel - // - TGeoManager *mgr = gGeoManager; - medSDDcf = mgr->GetMedium("ITSssdCarbonFiber"); - medSDDfs = mgr->GetMedium("ITSssdStaselite4411w"); - medSDDfo = mgr->GetMedium("ITSssdRohacell50A"); - medSDDss = mgr->GetMedium("ITSssdStainlessSteal"); - TGeoVolume *vA,*vB,*vC,*vD; - vA = new TGeoVolume("ITSsddCentCylCF",sA,medSDDcf); - vA->SetVisibility(kTRUE); - vA->SetLineColor(4); - vA->SetLineWidth(1); - vA->SetFillColor(vA->GetLineColor()); - vA->SetFillStyle(4030); // 30% transparent - vB = new TGeoVolume("ITSsddCentCylF",sB,medSDDfo); - vB->SetVisibility(kTRUE); - vB->SetLineColor(3); - vB->SetLineWidth(1); - vB->SetFillColor(vB->GetLineColor()); - vB->SetFillStyle(4050); // 50% transparent - vC = new TGeoVolume("ITSsddCentCylSt",sC,medSDDfs); - vC->SetVisibility(kTRUE); - vC->SetLineColor(2); - vC->SetLineWidth(1); - vC->SetFillColor(vC->GetLineColor()); - vC->SetFillStyle(4050); // 50% transparent - vD = new TGeoVolume("ITSsddCentCylSS",sD,medSDDss); - vD->SetVisibility(kTRUE); - vD->SetLineColor(1); - vD->SetLineWidth(1); - vD->SetFillColor(vD->GetLineColor()); - vD->SetFillStyle(4050); // 50% transparent - // - moth->AddNode(vA,1,0); - vA->AddNode(vC,1,0); - vC->AddNode(vB,1,0); - n = (Int_t)((360.*fgkDegree)/ktsBoltdAngle); - for(i=0;iAddNode(vD,i+1,tran); - tran = new TGeoTranslation("",x,y,-z); - vC->AddNode(vD,i+n+1,tran); - } // end for i - if(AliDebugLevel()){ - vA->PrintNodes(); - vB->PrintNodes(); - vC->PrintNodes(); - vD->PrintNodes(); - } // end if - // SDD Suport Cone - // - // - const Double_t kconThickness = 10.5*fgkmm;//Thickness Rohacell+car. fib. - const Double_t kconCthick = 1.5*fgkmm; // Carbon finber thickness - const Double_t kconRcurv = 15.0*fgkmm; // Radius of curvature. - const Double_t kconTc = 45.0; // angle of SDD cone [degrees]. - const Double_t kconZouterMilled = 23.0*fgkmm; - const Double_t kconZcylinder = 186.0*fgkmm; - const Double_t kconZ0 = kconZcylinder + 0.5*ktsLength; - //const Int_t kconNspoaks = 12; - //const Int_t kconNmounts = 4; - //const Double_t kconDmountAngle = 9.0; // degrees - const Double_t kconRoutMax = 0.5*560.0*fgkmm; - const Double_t kconRoutMin = 0.5*539.0*fgkmm; - // Holes in cone for cables - const Double_t kconPhiHole1 = 0.0*fgkDegree; - const Double_t kcondPhiHole1 = 25.0*fgkDegree; - const Double_t kconRholeMax1 = 0.5*528.*fgkmm; - const Double_t kconRholeMin1 = 0.5*464.*fgkmm; - const Double_t kconPhiHole2 = 0.0*fgkDegree; - const Double_t kcondPhiHole2 = 50.0*fgkDegree; - const Double_t kconRholeMax2 = 0.5*375.*fgkmm; - const Double_t kconRholeMin2 = 0.5*280.*fgkmm; - // - //const Int_t kconNpostsOut = 6; - //const Int_t kconNpostsIn = 3; - //const Double_t kconPhi0PostOut = 0.0; // degree - //const Double_t kconPhi0PostIn = 0.0; // degree - //const Double_t kcondRpostOut = 16.0*fgkmm; - //const Double_t kcondRpostIn = 16.0*fgkmm; - //const Double_t kconZpostMaxOut = 116.0*fgkmm; - //const Double_t kconZpostMaxIn = 190.0*fgkmm; - const Double_t kconRinMax = 0.5*216*fgkmm; - const Double_t kconRinCylinder = 0.5*231.0*fgkmm; - //const Double_t kconRinHole = 0.5*220.0*fgkmm; - const Double_t kconRinMin = 0.5*210.0*fgkmm; - const Double_t kcondZin = 15.0*fgkmm; // ??? - const Double_t kSinkconTc = SinD(kconTc); - const Double_t kCoskconTc = CosD(kconTc); - const Double_t kTankconTc = TanD(kconTc); - // - TGeoPcon *sE,*sF,*sG,*sH,*sI,*sJ,*sK; - TGeoCompositeShape *sL,*sM,*sN; - // - Double_t dza = kconThickness/kSinkconTc- - (kconRoutMax-kconRoutMin)/kTankconTc; - if(dza<=0){ // The number or order of the points are in error for a proper - // call to pcons! - Error("SDDcone","The definition of the points for a call to PCONS is" - " in error. abort."); - return; - } // end if - sE = new TGeoPcon("ITSsddSuportConeCarbonFiberSurfaceE",0.0,360.0,12); - sE->Z(0) = 0.0; - sE->Rmin(0) = kconRoutMin; - sE->Rmax(0) = kconRoutMax; - sE->Z(1) = kconZouterMilled - dza; - sE->Rmin(1) = sE->GetRmin(0); - sE->Rmax(1) = sE->GetRmax(0); - sE->Z(2) = kconZouterMilled; - sE->Rmax(2) = sE->GetRmax(0); - RadiusOfCurvature(kconRcurv,0.,sE->GetZ(1),sE->GetRmin(1),kconTc,z,rmin); - sE->Z(3) = z; - sE->Rmin(3) = rmin; - sE->Rmin(2) = RminFrom2Points(sE,3,1,sE->GetZ(2)); - RadiusOfCurvature(kconRcurv,0.,sE->GetZ(2),sE->GetRmax(2),kconTc,z,rmax); - sE->Z(4) = z; - sE->Rmax(4) = rmax; - sE->Rmin(4) = RminFromZpCone(sE,3,kconTc,sE->GetZ(4),0.0); - sE->Rmax(3) = RmaxFrom2Points(sE,4,2,sE->GetZ(3)); - sE->Rmin(7) = kconRinMin; - sE->Rmin(8) = kconRinMin; - RadiusOfCurvature(kconRcurv,90.0,0.0,kconRinMax,90.0-kconTc,z,rmax); - sE->Rmax(8) = rmax; - sE->Z(8) = ZFromRmaxpCone(sE,4,kconTc,sE->GetRmax(8)); - sE->Z(9) = kconZcylinder; - sE->Rmin(9) = kconRinMin; - sE->Z(10) = sE->GetZ(9); - sE->Rmin(10) = kconRinCylinder; - sE->Rmin(11) = kconRinCylinder; - sE->Rmax(11) = sE->GetRmin(11); - rmin = sE->GetRmin(8); - RadiusOfCurvature(kconRcurv,90.0-kconTc,sE->GetZ(8),sE->GetRmax(8),90.0, - z,rmax); - rmax = kconRinMax; - sE->Z(11) = z+(sE->GetZ(8)-z)*(sE->GetRmax(11)-rmax)/ - (sE->GetRmax(8)-rmax); - sE->Rmax(9) = RmaxFrom2Points(sE,11,8,sE->GetZ(9)); - sE->Rmax(10) = sE->GetRmax(9); - sE->Z(6) = z-kcondZin; - sE->Z(7) = sE->GetZ(6); - sE->Rmax(6) = RmaxFromZpCone(sE,4,kconTc,sE->GetZ(6)); - sE->Rmax(7) = sE->GetRmax(6); - RadiusOfCurvature(kconRcurv,90.,sE->GetZ(6),0.0,90.0-kconTc,z,rmin); - sE->Z(5) = z; - sE->Rmin(5) = RminFromZpCone(sE,3,kconTc,z); - sE->Rmax(5) = RmaxFromZpCone(sE,4,kconTc,z); - RadiusOfCurvature(kconRcurv,90.-kconTc,0.0,sE->Rmin(5),90.0,z,rmin); - sE->Rmin(6) = rmin; - // Inner Core, Inserto material - sF = new TGeoPcon("ITSsddSuportConeInsertoStesaliteF",0.,360.0,9); - sF->Z(0) = sE->GetZ(0); - sF->Rmin(0) = sE->GetRmin(0)+kconCthick; - sF->Rmax(0) = sE->GetRmax(0)-kconCthick; - sF->Z(1) = sE->GetZ(1); - sF->Rmin(1) = sF->GetRmin(0); - sF->Rmax(1) = sF->GetRmax(0); - sF->Z(2) = sE->GetZ(2); - sF->Rmax(2) = sF->GetRmax(1); - RadiusOfCurvature(kconRcurv-kconCthick,0.,sF->GetZ(1),sF->GetRmax(1), - kconTc,z,rmin); - sF->Z(3) = z; - sF->Rmin(3) = rmin; - sF->Rmin(2) = RminFrom2Points(sF,3,1,sF->GetZ(2)); - RadiusOfCurvature(kconRcurv+kconCthick,0.,sF->GetZ(2),sF->GetRmax(2), - kconTc,z,rmax); - sF->Z(4) = z; - sF->Rmax(4) = rmax; - sF->Rmin(4) = RmaxFromZpCone(sE,2,kconTc,sF->GetZ(4), - -kconCthick); - sF->Rmax(3) = RmaxFrom2Points(sF,4,2,sF->GetZ(3)); - sF->Rmin(7) = sE->GetRmin(7); - sF->Rmin(8) = sE->GetRmin(8); - sF->Z(6) = sE->GetZ(6)+kconCthick; - sF->Rmin(6) = sE->GetRmin(6); - sF->Z(7) = sF->GetZ(6); - sF->Rmax(8) = sE->GetRmax(8)-kconCthick*kSinkconTc; - RadiusOfCurvature(kconRcurv+kconCthick,90.0,sF->GetZ(6),sF->GetRmin(6), - 90.0-kconTc,z,rmin); - sF->Z(5) = z; - sF->Rmin(5) = rmin; - sF->Rmax(5) = RmaxFromZpCone(sF,4,kconTc,z); - sF->Rmax(6) = RmaxFromZpCone(sF,4,kconTc,sF->GetZ(6)); - sF->Rmax(7) = sF->GetRmax(6); - sF->Z(8) = ZFromRmaxpCone(sF,4,kconTc,sF->GetRmax(8),-kconCthick); - // Inner Core, Inserto material - sG = new TGeoPcon("ITSsddSuportConeFoamCoreG",0.0,360.0,4); - RadiusOfCurvature(kconRcurv+kconCthick,0.0,sF->GetZ(1),sF->GetRmin(1), - kconTc,z,rmin); - sG->Z(0) = z; - sG->Rmin(0) = rmin; - sG->Rmax(0) = sG->GetRmin(0); - sG->Z(1) = sG->GetZ(0)+(kconThickness-2.0*kconCthick)/kSinkconTc;; - sG->Rmin(1) = RminFromZpCone(sF,3,kconTc,sG->GetZ(1)); - sG->Rmax(1) = RmaxFromZpCone(sF,4,kconTc,sG->GetZ(1)); - sG->Z(2) = sE->GetZ(5)-kconCthick; - sG->Rmin(2) = RminFromZpCone(sF,3,kconTc,sG->GetZ(2)); - sG->Rmax(2) = RmaxFromZpCone(sF,4,kconTc,sG->GetZ(2)); - sG->Z(3) = sF->GetZ(5)+(kconThickness-2.0*kconCthick)*kCoskconTc; - sG->Rmax(3) = RmaxFromZpCone(sF,4,kconTc,sG->GetZ(3)); - sG->Rmin(3) = sG->GetRmax(3); - // - sH = new TGeoPcon("ITSsddSuportConeHoleH",kconPhiHole1,kcondPhiHole1,4); - sH->Rmin(0) = kconRholeMax1; - sH->Rmax(0) = sH->GetRmin(0); - sH->Z(0) = ZFromRminpCone(sE,3,kconTc,sH->GetRmin(0)); - sH->Rmax(1) = sH->GetRmax(0); - sH->Z(1) = ZFromRmaxpCone(sE,4,kconTc,sH->GetRmax(1)); - sH->Rmin(1) = RminFromZpCone(sE,3,kconTc,sH->GetZ(1)); - sH->Rmin(2) = kconRholeMin1; - sH->Z(2) = ZFromRminpCone(sE,3,kconTc,sH->GetRmin(2)); - sH->Rmax(2) = RmaxFromZpCone(sE,4,kconTc,sH->GetZ(2)); - sH->Rmin(3) = sH->GetRmin(2); - sH->Rmax(3) = sH->GetRmin(3); - sH->Z(3) = ZFromRminpCone(sE,3,kconTc,sH->GetRmin(3)); - // - x = kconCthick/(0.5*(kconRholeMax1+kconRholeMin1)); - t0 = kconPhiHole1 - x*fgkRadian; - t = kcondPhiHole1 + 2.0*x*fgkRadian; - sI = new TGeoPcon("ITSsddSuportConeHoleI",t0,t,4); - sI->Rmin(0) = kconRholeMax1+kconCthick; - sI->Rmax(0) = sI->GetRmin(0); - sI->Z(0) = ZFromRminpCone(sF,3,kconTc,sI->GetRmin(0)); - sI->Rmax(1) = sI->GetRmax(0); - sI->Z(1) = ZFromRmaxpCone(sF,4,kconTc,sI->GetRmax(1)); - sI->Rmin(1) = RminFromZpCone(sF,3,kconTc,sI->GetZ(1)); - sI->Rmin(2) = kconRholeMin1-kconCthick; - sI->Z(2) = ZFromRminpCone(sF,3,kconTc,sI->GetRmin(2)); - sI->Rmax(2) = RmaxFromZpCone(sF,4,kconTc,sI->GetZ(2)); - sI->Rmin(3) = sI->GetRmin(2); - sI->Rmax(3) = sI->GetRmin(3); - sI->Z(3) = ZFromRmaxpCone(sF,4,kconTc,sI->GetRmax(3)); - // - sJ = new TGeoPcon("ITSsddSuportConeHoleJ",kconPhiHole2, - kcondPhiHole2,4); - sJ->Rmin(0) = kconRholeMax2; - sJ->Rmax(0) = sJ->GetRmin(0); - sJ->Z(0) = ZFromRminpCone(sE,3,kconTc,sJ->GetRmin(0)); - sJ->Rmax(1) = sJ->GetRmax(0); - sJ->Z(1) = ZFromRmaxpCone(sE,4,kconTc,sJ->GetRmax(1)); - sJ->Rmin(1) = RminFromZpCone(sE,3,kconTc,sJ->GetZ(1)); - sJ->Rmin(2) = kconRholeMin2; - sJ->Z(2) = ZFromRminpCone(sE,3,kconTc,sJ->GetRmin(2)); - sJ->Rmax(2) = RmaxFromZpCone(sE,4,kconTc,sJ->GetZ(2)); - sJ->Rmin(3) = sJ->GetRmin(2); - sJ->Rmax(3) = sJ->GetRmin(3); - sJ->Z(3) = ZFromRmaxpCone(sE,4,kconTc,sJ->GetRmax(3)); - // - x = kconCthick/(0.5*(kconRholeMax2+kconRholeMin2)); - t0 = kconPhiHole2 - x*fgkRadian; - t = kcondPhiHole2 + 2.0*x*fgkRadian; - sK = new TGeoPcon("ITSsddSuportConeHoleK",t0,t,4); - sK->Rmin(0) = kconRholeMax2+kconCthick; - sK->Rmax(0) = sK->GetRmin(0); - sK->Z(0) = ZFromRminpCone(sF,3,kconTc,sK->GetRmin(0)); - sK->Rmax(1) = sK->GetRmax(0); - sK->Z(1) = ZFromRmaxpCone(sF,4,kconTc,sK->GetRmax(1)); - sK->Rmin(1) = RminFromZpCone(sF,3,kconTc,sK->GetZ(1)); - sK->Rmin(2) = kconRholeMin2-kconCthick; - sK->Z(2) = ZFromRminpCone(sF,3,kconTc,sK->GetRmin(2)); - sK->Rmax(2) = RmaxFromZpCone(sF,4,kconTc,sK->GetZ(2)); - sK->Rmin(3) = sK->GetRmin(2); - sK->Rmax(3) = sK->GetRmin(3); - sK->Z(3) = ZFromRmaxpCone(sF,4,kconTc,sK->GetRmax(3)); - // - rot = new TGeoRotation("ITSsddRotZ30",0.0,0.0,30.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ60",0.0,0.0,60.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ90",0.0,0.0,90.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ120",0.0,0.0,120.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ150",0.0,0.0,150.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ180",0.0,0.0,180.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ210",0.0,0.0,210.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ240",0.0,0.0,240.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ270",0.0,0.0,270.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ300",0.0,0.0,300.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - rot = new TGeoRotation("ITSsddRotZ330",0.0,0.0,330.0); - rot->RegisterYourself(); - if(AliDebugLevel()) rot->Print(); - sL = new TGeoCompositeShape("ITS SDD Suport Cone","(((((((((((((((((" - "ITSsddSuportConeCarbonFiberSurfaceE -" - "ITSsddSuportConeHoleH) -" - "ITSsddSuportConeHoleH:ITSsddRotZ30) -" - "ITSsddSuportConeHoleH:ITSsddRotZ60) -" - "ITSsddSuportConeHoleH:ITSsddRotZ90) -" - "ITSsddSuportConeHoleH:ITSsddRotZ120) -" - "ITSsddSuportConeHoleH:ITSsddRotZ150) -" - "ITSsddSuportConeHoleH:ITSsddRotZ180) -" - "ITSsddSuportConeHoleH:ITSsddRotZ210) -" - "ITSsddSuportConeHoleH:ITSsddRotZ240) -" - "ITSsddSuportConeHoleH:ITSsddRotZ270) -" - "ITSsddSuportConeHoleH:ITSsddRotZ300) -" - "ITSsddSuportConeHoleH:ITSsddRotZ330) -" - "ITSsddSuportConeHoleJ) -" - "ITSsddSuportConeHoleJ:ITSsddRotZ60) -" - "ITSsddSuportConeHoleJ:ITSsddRotZ120) -" - "ITSsddSuportConeHoleJ:ITSsddRotZ180) -" - "ITSsddSuportConeHoleJ:ITSsddRotZ240) -" - "ITSsddSuportConeHoleJ:ITSsddRotZ300"); - sM = new TGeoCompositeShape("ITS SDD Suport Cone Inserto Stesalite", - "(((((((((((((((((" - "ITSsddSuportConeInsertoStesaliteF -" - "ITSsddSuportConeHoleI) -" - "ITSsddSuportConeHoleI:ITSsddRotZ30) -" - "ITSsddSuportConeHoleI:ITSsddRotZ60) -" - "ITSsddSuportConeHoleI:ITSsddRotZ90) -" - "ITSsddSuportConeHoleI:ITSsddRotZ120) -" - "ITSsddSuportConeHoleI:ITSsddRotZ150) -" - "ITSsddSuportConeHoleI:ITSsddRotZ180) -" - "ITSsddSuportConeHoleI:ITSsddRotZ210) -" - "ITSsddSuportConeHoleI:ITSsddRotZ240) -" - "ITSsddSuportConeHoleI:ITSsddRotZ270) -" - "ITSsddSuportConeHoleI:ITSsddRotZ300) -" - "ITSsddSuportConeHoleI:ITSsddRotZ330) -" - "ITSsddSuportConeHoleK) -" - "ITSsddSuportConeHoleK:ITSsddRotZ60) -" - "ITSsddSuportConeHoleK:ITSsddRotZ120) -" - "ITSsddSuportConeHoleK:ITSsddRotZ180) -" - "ITSsddSuportConeHoleK:ITSsddRotZ240) -" - "ITSsddSuportConeHoleK:ITSsddRotZ300"); - sN = new TGeoCompositeShape("ITS SDD Suport Cone Foam Core", - "(((((((((((((((((" - "ITSsddSuportConeFoamCoreG -" - "ITSsddSuportConeHoleI) -" - "ITSsddSuportConeHoleI:ITSsddRotZ30) -" - "ITSsddSuportConeHoleI:ITSsddRotZ60) -" - "ITSsddSuportConeHoleI:ITSsddRotZ90) -" - "ITSsddSuportConeHoleI:ITSsddRotZ120) -" - "ITSsddSuportConeHoleI:ITSsddRotZ150) -" - "ITSsddSuportConeHoleI:ITSsddRotZ180) -" - "ITSsddSuportConeHoleI:ITSsddRotZ210) -" - "ITSsddSuportConeHoleI:ITSsddRotZ240) -" - "ITSsddSuportConeHoleI:ITSsddRotZ270) -" - "ITSsddSuportConeHoleI:ITSsddRotZ300) -" - "ITSsddSuportConeHoleI:ITSsddRotZ330) -" - "ITSsddSuportConeHoleK) -" - "ITSsddSuportConeHoleK:ITSsddRotZ60) -" - "ITSsddSuportConeHoleK:ITSsddRotZ120) -" - "ITSsddSuportConeHoleK:ITSsddRotZ180) -" - "ITSsddSuportConeHoleK:ITSsddRotZ240) -" - "ITSsddSuportConeHoleK:ITSsddRotZ300"); - //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - if(AliDebugLevel()){ - sE->InspectShape(); - sF->InspectShape(); - sG->InspectShape(); - sH->InspectShape(); - sI->InspectShape(); - sJ->InspectShape(); - sK->InspectShape(); - sL->InspectShape(); - sM->InspectShape(); - sN->InspectShape(); - } // end if AliDebugLevel() - // - TGeoVolume *vL,*vM,*vN; - vL = new TGeoVolume("ITSsddConeL",sL,medSDDcf); - vL->SetVisibility(kTRUE); - vL->SetLineColor(4); - vL->SetLineWidth(1); - vL->SetFillColor(vL->GetLineColor()); - vL->SetFillStyle(4000); // 0% transparent - vM = new TGeoVolume("ITSsddConeM",sM,medSDDfs); - vM->SetVisibility(kTRUE); - vM->SetLineColor(2); - vM->SetLineWidth(1); - vM->SetFillColor(vM->GetLineColor()); - vM->SetFillStyle(4010); // 10% transparent - vN = new TGeoVolume("ITSsddConeN",sN,medSDDfo); - vN->SetVisibility(kTRUE); - vN->SetLineColor(7); - vN->SetLineWidth(1); - vN->SetFillColor(vN->GetLineColor()); - vN->SetFillStyle(4050); // 50% transparent - // - vM->AddNode(vN,1,0); - vL->AddNode(vM,1,0); - tran = new TGeoTranslation("",0.0,0.0,-kconZ0); - moth->AddNode(vL,1,tran); - rot = new TGeoRotation("",0.0,180.0*fgkDegree,0.0); - rotran = new TGeoCombiTrans("",0.0,0.0,kconZ0,rot); - moth->AddNode(vL,2,rotran); - if(AliDebugLevel()){ - tran->Print(); - rot->Print(); - rotran->Print(); - vL->PrintNodes(); - vM->PrintNodes(); - vN->PrintNodes(); - } // end if - delete rot;// rot not explicity used in AddNode functions. +void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide, + const Double_t length, const Double_t r10, + Double_t *x, Double_t *y){ +// +// Creates the proper sequence of X and Y coordinates to determine +// the base XTru polygon for the holes in the SDD and SSD tray covers +// (here the rounded corners are approximated with segments) +// +// Input: +// wide : the hole wide +// length : the hole length +// r10 : the radius of the rounded corners +// +// Output: +// x, y : coordinate vectors [16] +// +// Created: 03 Jan 2010 Mario Sitta +// +// Caller must guarantee that x and y have the correct dimensions +// (but being this a private method it's easy to tell) +// + + x[0] = wide/2 - r10; + y[0] = length; + x[1] = x[0] + r10*SinD(30); + y[1] = y[0] - r10*(1 - CosD(30)); + x[2] = x[0] + r10*SinD(60); + y[2] = y[0] - r10*(1 - CosD(60)); + x[3] = x[0] + r10; + y[3] = y[0] - r10; + x[4] = x[3]; + y[4] = r10; + x[5] = x[4] - r10*(1 - CosD(30)); + y[5] = y[4] - r10*SinD(30); + x[6] = x[4] - r10*(1 - CosD(60)); + y[6] = y[4] - r10*SinD(60); + x[7] = x[4] - r10; + y[7] = 0; + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 8; jp++) { + x[8+jp] = -x[7-jp]; + y[8+jp] = y[7-jp]; + } + + return; } + //______________________________________________________________________ -void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth){ - // Define the detail SSD support cone geometry. - // Inputs: - // TGeo Volume *moth The mother volume to place this object. - // Outputs: - // none. - // Return: - // none. - // - Int_t i,j; - Double_t t,t0,dt,x,y,z,vl[3],vg[3],x0,y0,rmin,rmax; - TGeoMedium *medSSDcf = 0; // SSD support cone Carbon Fiber materal number. - TGeoMedium *medSSDfs = 0; // SSD support cone inserto stesalite 4411w. - TGeoMedium *medSSDfo = 0; // SSD support cone foam, Rohacell 50A. - TGeoMedium *medSSDss = 0; // SSD support cone screw material,Stainless - TGeoMedium *medSSDair = 0; // SSD support cone Air - TGeoMedium *medSSDal = 0; // SSD support cone SDD mounting bracket Al - TGeoManager *mgr = gGeoManager; - medSSDcf = mgr->GetMedium("ITSssdCarbonFiber"); - medSSDfs = mgr->GetMedium("ITSssdStaselite4411w"); - medSSDfo = mgr->GetMedium("ITSssdRohacell50A"); - medSSDss = mgr->GetMedium("ITSssdStainlessSteal"); - medSSDair= mgr->GetMedium("ITSssdAir"); - medSSDal = mgr->GetMedium("ITSssdAl"); - // - // SSD Central cylinder/Thermal Sheald. - const Double_t kcylZlength = 1140.0*fgkmm; // - const Double_t kcylZFoamlength = 1020.0*fgkmm; // - const Double_t kcylROuter = 0.5*595.0*fgkmm; // - const Double_t kcylRInner = 0.5*560.5*fgkmm; // - const Double_t kcylCthick = 0.64*fgkmm; // - const Double_t kcylFoamThick = 5.0*fgkmm; // - const Double_t kcylRholes = 0.5*575.0*fgkmm; - const Double_t kcylZM6 = 6.0*fgkmm; // - const Double_t kcylRM6 = 0.5*6.0*fgkmm; - const Double_t kcylPhi0M6 = 0.0*fgkDegree; - const Int_t kcylNM6 = 40; - const Double_t kcylZPin = 10.0*fgkmm; - const Double_t kcylRPin = 0.5*4.0*fgkmm; - const Double_t kcylPhi0Pin = (90.0+4.5)*fgkDegree; - const Int_t kcylNPin = 2; - // - TGeoPcon *sCA,*sCB; - TGeoTube *sCC,*sCD,*sCE; - // - //Begin_Html - /* - -

- - ITS SSD centreal support and thermal sheal cylinder. - -

- */ - //End_Html - // - sCC = new TGeoTube("ITS SSD Thermal Centeral Rohacell CylinderCC", - kcylROuter-kcylCthick-kcylFoamThick, - kcylROuter-kcylCthick,0.5*kcylZFoamlength); - sCA = new TGeoPcon("ITS SSD Thermal Centeral Carbon Fiber CylinderCA", - 0.0,360.0,6); - sCB = new TGeoPcon("ITS SSD Thermal Centeral Stesalite CylinderCB", - 0.0,360.0,6); - sCA->Z(0) = -0.5*kcylZlength; - sCA->Rmin(0) = kcylRInner; - sCA->Rmax(0) = kcylROuter; - sCA->Z(1) = sCA->GetZ(0) + kcylZM6; - sCA->Rmin(1) = sCA->GetRmin(0); - sCA->Rmax(1) = sCA->GetRmax(0); - sCA->Z(2) = -0.5*kcylZFoamlength; - sCA->Rmin(2) = kcylROuter - 2.0*kcylCthick-kcylFoamThick; - sCA->Rmax(2) = sCA->GetRmax(0); - sCA->Z(3) = -sCA->GetZ(2); - sCA->Rmin(3) = sCA->GetRmin(2); - sCA->Rmax(3) = sCA->GetRmax(2); - sCA->Z(4) = -sCA->GetZ(1); - sCA->Rmin(4) = sCA->GetRmin(1); - sCA->Rmax(4) = sCA->GetRmax(1); - sCA->Z(5) = -sCA->GetZ(0); - sCA->Rmin(5) = sCA->GetRmin(0); - sCA->Rmax(5) = sCA->GetRmax(0); - // - sCB->Z(0) = sCA->GetZ(0); - sCB->Rmin(0) = sCA->GetRmin(0) + kcylCthick; - sCB->Rmax(0) = sCA->GetRmax(0) - kcylCthick; - sCB->Z(1) = sCA->GetZ(1); - sCB->Rmin(1) = sCA->GetRmin(1) + kcylCthick; - sCB->Rmax(1) = sCA->GetRmax(1) - kcylCthick; - sCB->Z(2) = sCA->GetZ(2); - sCB->Rmin(2) = sCA->GetRmin(2) + kcylCthick; - sCB->Rmax(2) = sCA->GetRmax(2) - kcylCthick; - sCB->Z(3) = sCA->GetZ(3); - sCB->Rmin(3) = sCA->GetRmin(3) + kcylCthick; - sCB->Rmax(3) = sCA->GetRmax(3) - kcylCthick; - sCB->Z(4) = sCA->GetZ(4); - sCB->Rmin(4) = sCA->GetRmin(4) + kcylCthick; - sCB->Rmax(4) = sCA->GetRmax(4) - kcylCthick; - sCB->Z(5) = sCA->GetZ(5); - sCB->Rmin(5) = sCA->GetRmin(5) + kcylCthick; - sCB->Rmax(5) = sCA->GetRmax(5) - kcylCthick; - // - sCD = new TGeoTube("ITS SSD Thermal Centeral Cylinder M6 screwCD", - 0.0,kcylRM6,0.5*kcylZM6); - sCE = new TGeoTube("ITS SSD Thermal Centeral Cylinder PinCE", - 0.0,kcylRPin,0.5*kcylZPin); - // - if(AliDebugLevel()){ - sCA->InspectShape(); - sCB->InspectShape(); - sCC->InspectShape(); - sCD->InspectShape(); - sCE->InspectShape(); - } // end if GetDegut() - TGeoVolume *vCA,*vCB,*vCC,*vCD,*vCE; - vCA = new TGeoVolume("ITSssdCentCylCA",sCA,medSSDcf); - vCA->SetVisibility(kTRUE); - vCA->SetLineColor(4); // blue - vCA->SetLineWidth(1); - vCA->SetFillColor(vCA->GetLineColor()); - vCA->SetFillStyle(4000); // 0% transparent - vCB = new TGeoVolume("ITSssdCentCylCB",sCB,medSSDfs); - vCB->SetVisibility(kTRUE); - vCB->SetLineColor(2); // red - vCB->SetLineWidth(1); - vCB->SetFillColor(vCB->GetLineColor()); - vCB->SetFillStyle(4050); // 50% transparent - vCC = new TGeoVolume("ITSssdCentCylCC",sCC,medSSDfo); - vCC->SetVisibility(kTRUE); - vCC->SetLineColor(3); // green - vCC->SetLineWidth(1); - vCC->SetFillColor(vCC->GetLineColor()); - vCC->SetFillStyle(4050); // 50% transparent - vCD = new TGeoVolume("ITSssdCentCylCD",sCD,medSSDss); - vCD->SetVisibility(kTRUE); - vCD->SetLineColor(1); // black - vCD->SetLineWidth(1); - vCD->SetFillColor(vCD->GetLineColor()); - vCD->SetFillStyle(4000); // 0% transparent - vCE = new TGeoVolume("ITSssdCentCylCE",sCE,medSSDss); - vCE->SetVisibility(kTRUE); - vCE->SetLineColor(1); // black - vCE->SetLineWidth(1); - vCE->SetFillColor(vCE->GetLineColor()); - vCE->SetFillStyle(4000); // 0% transparent - // Insert Bolt and Pins in both the Cone and Cylinder at the same time. - vCB->AddNode(vCC,1,0); - vCA->AddNode(vCB,1,0); - moth->AddNode(vCA,1,0); - if(AliDebugLevel()){ - vCA->PrintNodes(); - vCB->PrintNodes(); - vCC->PrintNodes(); - vCD->PrintNodes(); - vCE->PrintNodes(); - } // end if - // - // SSD Cone - // Data from Drawings ALR 0743/2E "Supporto Globale Settore SSD" and - // ALR 0743/2A "Supporto Generale Settore SSD". - // - const Double_t kconThick = 13.0*fgkmm; // Thickness of Cone. - const Double_t kconCthick = 0.75*fgkmm; // Car. finber thickness - const Double_t kconRCurv0 = 10.0*fgkmm; // Radius of curvature. - const Double_t kconRCurv1 = 25.0*fgkmm; // Radius of curvature. - const Double_t kconT = 39.0*fgkDegree; // angle of SSD cone. - const Double_t kconZOuterRing = 47.0*fgkmm; - const Double_t kconZOuterRingMill = kconZOuterRing-5.0*fgkmm; - const Double_t kconZToCylinder = 170.0*fgkmm; - const Double_t kconZLengthMill = 171.5*fgkmm; - const Double_t kconZLength = 176.5*fgkmm- - (kconZOuterRing-kconZOuterRingMill); - //const Double_t kconZInnerRing = 161.5*fgkmm- - // (kconZOuterRing-kconZOuterRingMill); - const Double_t kconZOuterRingInside = 30.25*fgkmm- - (kconZOuterRing-kconZOuterRingMill); - const Double_t kconZDisplacement = kconZToCylinder + 0.5*kcylZlength; - const Double_t kconROuterMax = 0.5*985.0*fgkmm; - const Double_t kconROuterMin = 0.5*945.0*fgkmm; - const Double_t kconRCylOuterMill = 0.5*597.0*fgkmm; - const Double_t kconRInnerMin = 0.5*562.0*fgkmm; - //const Double_t kconRCentCurv0 = 0.5*927.0*fgkmm; - const Double_t kconRCentCurv1 = 0.5*593.0*fgkmm; - const Double_t kconRCentCurv2 = 0.5*578.0*fgkmm; - // Foam core. - const Double_t kconRohacellL0 = 112.3*fgkmm; - const Double_t kconRohacellL1 = 58.4*fgkmm; - // Screws and pins in outer SSD cone ring - const Double_t kconROutHoles = 0.5*965.0*fgkmm; - const Double_t kconRScrewM5by12 = 0.5*5.0*fgkmm; - const Double_t kconLScrewM5by12 = 0.5*12.0*fgkmm; - const Int_t kconNScrewM5by12 = 2; - const Double_t kconRPinO6 = 0.5*6.0*fgkmm; - const Double_t kconLPinO6 = 0.5*10.0*fgkmm; - const Int_t kconNPinO6 = 3; - const Int_t kconNRailScrews = 4; - const Int_t kconNRailPins = 2; - const Int_t kconNmounts = 4; - const Double_t kconMountPhi0 = 9.0*fgkDegree; // degrees - // - const Double_t kconCableHoleROut = 0.5*920.0*fgkmm; - const Double_t kconCableHoleRinner = 0.5*800.0*fgkmm; - const Double_t kconCableHoleWidth = 200.0*fgkmm; - const Double_t kconCableHoleAngle = 42.0*fgkDegree; - //const Double_t kconCableHolePhi0 = 90.0/4.0*fgkDegree; - //const Int_t kconNCableHoles = 8; - const Double_t kconCoolHoleWidth = 40.0*fgkmm; - const Double_t kconCoolHoleHight = 30.0*fgkmm; - const Double_t kconCoolHoleRmin = 350.0*fgkmm; - //const Double_t kconCoolHolephi0 = 90.0/4.0*fgkDegree; - //const Int_t kconNCoolHoles = 8; - const Double_t kconMountHoleWidth = 20.0*fgkmm; - const Double_t kconMountHoleHight = 20.0*fgkmm; - const Double_t kconMountHoleRmin = 317.5*fgkmm; - //const Double_t kconMountHolephi0 = 0.0*fgkDegree; - //const Int_t kconNMountHoles = 6; - // SSD cone Wings with holes. - const Double_t kconWingRmax = 527.5*fgkmm; - const Double_t kconWingWidth = 70.0*fgkmm; - const Double_t kconWingThick = 10.0*fgkmm; - const Double_t kconWingPhi0 = 45.0*fgkDegree; - //const Int_t kconNWings = 4; - // SSD-SDD Thermal/Mechanical cylinder mounts - const Double_t kconRM6Head = 8.0*fgkmm; - const Double_t kconZM6Head = 8.5*fgkmm; - // - // SSD-SDD Mounting bracket - const Double_t ksupPRmin = 0.5*539.0*fgkmm;// see SDD RoutMin - const Double_t ksupPRmax = 0.5*585.0*fgkmm; - const Double_t ksupPZ = 3.5*fgkmm; - const Double_t ksupPPhi1 = (-0.5*70.*fgkmm/ksupPRmax)*fgkRadian; - const Double_t ksupPPhi2 = -ksupPPhi1; - // - const Double_t kSinkconTc = SinD(kconT); - const Double_t kCoskconTc = CosD(kconT); - // - TGeoPcon *sA0,*sB0,*sC0,*sF0,*sQ; - TGeoConeSeg *sAh1,*sBh1; - TGeoArb8 *sAh2,*sBh2; - TGeoBBox *sAh3,*sBh3,*sAh4,*sBh4; - TGeoConeSeg *sG,*sH; - TGeoTubeSeg *sT; - TGeoTube *sD,*sE,*sR,*sS; - TGeoCompositeShape *sA,*sB,*sC,*sF; - // - // Lets start with the upper left outer carbon fiber surface. - // Between za[2],rmaxa[2] and za[4],rmaxa[4] there is a curved section - // given by rmaxa = rmaxa[2]-r*Sind(t) for 0<=t<=kconT and - // za = za[2] + r*Cosd(t) for 0<=t<=kconT. Simularly between za[1],rmina[1 - // and za[3],rmina[3] there is a curve section given by - // rmina = rmina[1]-r*Sind(t) for 0<=t<=kconT and za = za[1]+r&Sind(t) - // for t<=0<=kconT. These curves have been replaced by straight lines - // between the equivelent points for simplicity. - // Poly-cone Volume sA0. Top part of SSD cone Carbon Fiber. - sA0 = new TGeoPcon("ITSssdSuportConeCarbonFiberSurfaceA0",0.0,360.0,15); - sA0->Z(0) = 0.0; - sA0->Rmin(0) = kconROuterMin; - sA0->Rmax(0) = kconROuterMax; - sA0->Z(1) = kconZOuterRingInside-kconRCurv0; - sA0->Rmin(1) = sA0->GetRmin(0); - sA0->Rmax(1) = sA0->GetRmax(0); - sA0->Z(2) = kconZOuterRingInside; - sA0->Rmin(2) = sA0->GetRmin(1)-kconRCurv0; - sA0->Rmax(2) = sA0->GetRmax(0); - sA0->Z(3) = sA0->GetZ(2); - sA0->Rmin(3) = -1000; // See Below - sA0->Rmax(3) = sA0->GetRmax(0); - sA0->Z(4) = kconZOuterRingMill-kconRCurv0; - sA0->Rmin(4) = -1000; // See Below - sA0->Rmax(4) = sA0->GetRmax(0); - sA0->Z(5) = kconZOuterRingMill; - sA0->Rmin(5) = -1000; // See Below - sA0->Rmax(5) = sA0->GetRmax(4) - kconRCurv0; - sA0->Z(6) = sA0->GetZ(5); - sA0->Rmin(6) = -1000; // See Below - sA0->Rmax(6) = -1000; // See Below - sA0->Z(7) = sA0->GetZ(6)+kconRCurv0*(1.-kCoskconTc); - sA0->Rmin(7) = -1000; // See Below - sA0->Rmax(7) = -1000; // See Below - sA0->Z(8) = -1000; // See Below - sA0->Rmin(8) = kconRCentCurv2+kconRCurv1*kSinkconTc; // See Below - sA0->Rmax(8) = -1000; // See Below - sA0->Z(9) = -1000; // See Below - sA0->Rmin(9) = kconRCentCurv2; - sA0->Rmax(9) = -1000; // See Below - sA0->Z(10) = -1000; // See Below - sA0->Rmin(10)= kconRInnerMin; - sA0->Rmax(10)= -1000; // See Below - sA0->Z(11) = kconZLengthMill-kconRCurv0*(1.0-kCoskconTc); - sA0->Rmin(11)= sA0->GetRmin(10); - sA0->Rmax(11)= kconRCentCurv1+kconRCurv0*kSinkconTc; - sA0->Z(12) = kconZToCylinder; - sA0->Rmin(12)= sA0->GetRmin(10); - sA0->Rmax(12)= -1000; // See Below - sA0->Z(13) = sA0->GetZ(12); - sA0->Rmin(13)= kconRCylOuterMill; - sA0->Rmax(13)= -1000; // See Below - z = kconZLengthMill; - rmin = kconRCentCurv1; - rmax = rmin; - sA0->Z(14) = -1000; // See Below - sA0->Rmin(14)= sA0->GetRmin(13); - sA0->Rmax(14)= sA0->GetRmin(14); - // Compute values undefined above - sA0->Z(14) = Xfrom2Points(sA0->GetZ(11),sA0->GetRmax(11),z,rmax, - sA0->GetRmax(14)); - sA0->Z(8) = ZFromRmaxpCone(sA0,11,90.-kconT,sA0->GetRmin(8),-kconThick); - sA0->Rmax(8) = RmaxFromZpCone(sA0,11,90.-kconT,sA0->GetZ(8),0.0); - sA0->Z(9) = sA0->GetZ(8)+kconRCurv1*(1.-kCoskconTc); - sA0->Z(10) = sA0->GetZ(9); - sA0->Rmin(3) = RminFromZpCone(sA0,8,90.-kconT,sA0->GetZ(3),0.0); - sA0->Rmin(4) = RminFromZpCone(sA0,3,90.-kconT,sA0->GetZ(4),0.0); - sA0->Rmin(5) = RminFromZpCone(sA0,3,90.-kconT,sA0->GetZ(5),0.0); - sA0->Rmin(7) = RminFromZpCone(sA0,3,90.-kconT,sA0->GetZ(7),0.0); - sA0->Rmax(7) = RmaxFromZpCone(sA0,11,90.-kconT,sA0->GetZ(7),0.0); - sA0->Rmin(6) = sA0->GetRmin(5); - sA0->Rmax(6) = RmaxFromZpCone(sA0,11,90.-kconT,sA0->GetZ(7),0.0); - sA0->Rmax(9) = RmaxFromZpCone(sA0,11,90.-kconT,sA0->GetZ(9),0.0); - sA0->Rmax(10)= sA0->GetRmax(9); - t = TanD(270.+kconT); - sA0->Rmax(12)= RmaxFrom2Points(sA0,11,14,sA0->GetZ(12)); - sA0->Rmax(13)= sA0->GetRmax(12); - // - // Poly-cone Volume B. Stesalite inside volume sA0. - // Now lets define the Inserto Stesalite 4411w material volume. - // Poly-cone Volume sA0. Top part of SSD cone Carbon Fiber. - sB0 = new TGeoPcon("ITSssdSuportConeStaseliteB0",0.0,360.0,15); - // - sB0->Z(0) = sA0->GetZ(0); - sB0->Rmin(0) = sA0->GetRmin(0) + kconCthick; - sB0->Rmax(0) = sA0->GetRmax(0) - kconCthick; - InsidePoint(sA0,0,1,2,kconCthick,sB0,1,kFALSE); // Rmin - sB0->Rmax(1) = sB0->Rmax(0); - InsidePoint(sA0,1,2,3,kconCthick,sB0,2,kFALSE); // Rmin - sB0->Rmax(2) = sB0->Rmax(0); - InsidePoint(sA0,2,3,9,kconCthick,sB0,3,kFALSE); - sB0->Rmax(3) = sB0->Rmax(0); - InsidePoint(sA0,0,4,5,kconCthick,sB0,4,kTRUE); // Rmax - sB0->Rmin(4) = -1000.; // see Bellow - InsidePoint(sA0,4,5,6,kconCthick,sB0,5,kTRUE); // Rmax - sB0->Rmin(5) = -1000.; // see Bellow - InsidePoint(sA0,5,6,7,kconCthick,sB0,6,kTRUE); // Rmax - sB0->Rmin(6) = -1000.; // see Bellow - InsidePoint(sA0,6,7,11,kconCthick,sB0,7,kTRUE); // Rmax - sB0->Rmin(7) = -1000.; // see Bellow - InsidePoint(sA0,3,8,9,kconCthick,sB0,8,kFALSE); // Rmin - sB0->Rmax(8) = -1000.; // see Bellow - InsidePoint(sA0,8,9,10,kconCthick,sB0,9,kFALSE); // Rmin - sB0->Rmax(9) = -1000.; // see Bellow - sB0->Z(10) = sA0->GetZ(10) + kconCthick; - sB0->Rmin(10)= sA0->GetRmin(10); - sB0->Rmax(10)= -1000.; // see Bellow - InsidePoint(sA0,7,11,14,kconCthick,sB0,11,kTRUE); // Rmax - sB0->Rmin(11)= sA0->GetRmin(10); - sB0->Z(12) = sA0->GetZ(12); - sB0->Rmin(12)= sA0->GetRmin(12); - sB0->Rmax(12)= -1000.; // see Bellow - sB0->Z(13) = sA0->GetZ(13); - sB0->Rmin(13)= sA0->GetRmin(13); - sB0->Rmax(13)= -1000.; // see Bellow - sB0->Z(14) = sA0->GetZ(14) - kconCthick; - sB0->Rmin(14)= sA0->GetRmin(14); - sB0->Rmax(14)= sB0->Rmin(14); // Close? - sB0->Rmin(4) = RminFrom2Points(sB0,3,8,sB0->GetZ(4)); - sB0->Rmin(5) = RminFrom2Points(sB0,3,8,sB0->GetZ(5)); - sB0->Rmin(6) = sB0->GetRmin(5); - sB0->Rmin(7) = RminFrom2Points(sB0,3,8,sB0->GetZ(7)); - sB0->Rmax(8) = RmaxFrom2Points(sB0,7,11,sB0->GetZ(8)); - sB0->Rmax(9) = RmaxFrom2Points(sB0,7,11,sB0->GetZ(9)); - sB0->Rmax(10)= sB0->GetRmax(9); - sB0->Rmax(12)= RmaxFrom2Points(sB0,11,14,sB0->GetZ(12)); - sB0->Rmax(13)= RmaxFrom2Points(sB0,11,14,sB0->GetZ(13)); - // - // Poly-cone Volume sC0. Foam inside volume sA0. - // Now lets define the Rohacell foam material volume. - sC0 = new TGeoPcon("ITSssdSuportConeRohacellC0",0.0,360.0,4); - sC0->Z(1) = sB0->GetZ(7); - sC0->Rmax(1) = sB0->GetRmax(7); - sC0->Rmin(1) = RminFrom2Points(sB0,3,8,sC0->GetZ(1)); - sC0->Rmin(0) = sC0->GetRmax(1); - sC0->Rmax(0) = sC0->GetRmin(0); - sC0->Z(0) = Zfrom2MinPoints(sB0,3,8,sC0->Rmin(0)); - t = kconThick-2.0*kconCthick; - sC0->Rmax(3) = sC0->GetRmax(0)-kCoskconTc*TMath::Sqrt( - kconRohacellL0*kconRohacellL0-t*t)+t*kSinkconTc; - sC0->Rmin(3) = sC0->GetRmax(3); - sC0->Z(3) = ZFromRmaxpCone(sB0,11,90.-kconT,sC0->GetRmax(3),0.0);; - sC0->Rmin(2) = sC0->GetRmin(3); - sC0->Z(2) = ZFromRminpCone(sB0,3,90.-kconT,sC0->GetRmin(2),0.0); - sC0->Rmax(2) = RmaxFromZpCone(sB0,11,90.0-kconT,sC0->GetZ(2),0.0); - // - // Poly-cone Volume sF0. Second Foam inside volume sA0. - // Now lets define the Rohacell foam material volume. - sF0 = new TGeoPcon("ITSssdSuportConeRohacellCF0",0.0,360.0,4); - sF0->Z(2) = sB0->GetZ(8); - sF0->Rmin(2) = sB0->GetRmin(8); - sF0->Rmax(2) = sB0->GetRmax(8); - sF0->Z(0) = sF0->GetZ(2)-kconRohacellL1*kSinkconTc; - sF0->Rmin(0) = sF0->GetRmin(2)+kconRohacellL1*kCoskconTc; - sF0->Rmax(0) = sF0->GetRmin(0); - sF0->Z(1) = ZFromRmaxpCone(sB0,11,90.-kconT,sF0->GetRmax(0),0.0);; - sF0->Rmax(1) = sF0->GetRmax(0); - sF0->Rmin(1) = RminFrom2Points(sB0,3,8,sF0->GetZ(1)); - sF0->Rmax(3) = sF0->GetRmin(2)+(kconThick-2.0*kconCthick)*kCoskconTc; - sF0->Rmin(3) = sF0->GetRmax(3); - sF0->Z(3) = ZFromRmaxpCone(sB0,11,90.-kconT,sF0->GetRmax(3),0.0); - // Holes for Cables to pass Through is created by the intersection - // between a cone segment and an Arb8, One for the volume sA0 and a - // larger one for the volumes sB0 and sC0, so that the surface is covered - // in carbon figer (volume sA0). - sAh1 = new TGeoConeSeg("ITSssdCableHoleAh1", - 0.5*kconZLength,kconCableHoleRinner, - kconCableHoleROut,kconCableHoleRinner, - kconCableHoleROut, - 90.-(0.5*kconCableHoleWidth/ - kconCableHoleROut)*fgkRadian, - 90.+(0.5*kconCableHoleWidth/ - kconCableHoleROut)*fgkRadian); - sBh1 = new TGeoConeSeg("ITSssdCableHoleBh1",0.5*kconZLength, - kconCableHoleRinner-kconCthick, - kconCableHoleROut+kconCthick, - kconCableHoleRinner-kconCthick, - kconCableHoleROut+kconCthick, - 90.-(((0.5*kconCableHoleWidth+kconCthick)/ - (kconCableHoleROut+kconCthick)))*fgkRadian, - 90.+(((0.5*kconCableHoleWidth+kconCthick)/ - (kconCableHoleROut+kconCthick)))*fgkRadian); - x0 = sAh1->GetRmax1()*CosD(sAh1->GetPhi2()); - y0 = sAh1->GetRmax1()*SinD(sAh1->GetPhi2()); - sAh2 = new TGeoArb8("ITSssdCableHoleAh2",0.5*kconZLength); - y = sAh1->GetRmax1(); - x = x0+(y-y0)/TanD(90.0+kconCableHoleAngle); - sAh2->SetVertex(0,x,y); - y = sAh1->GetRmin1()*SinD(sAh1->GetPhi2()); - x = x0+(y-y0)/TanD(90.0+kconCableHoleAngle); - sAh2->SetVertex(3,x,y); - x0 = sAh1->GetRmax1()*CosD(sAh1->GetPhi1()); - y0 = sAh1->GetRmax1()*SinD(sAh1->GetPhi1()); - y = sAh1->GetRmax1(); - x = x0+(y-y0)/TanD(90.0-kconCableHoleAngle); - sAh2->SetVertex(1,x,y); - y = sAh1->GetRmin1()*SinD(sAh1->GetPhi1()); - x = x0+(y-y0)/TanD(90.0-kconCableHoleAngle); - sAh2->SetVertex(2,x,y); - // - x0 = sBh1->GetRmax1()*CosD(sBh1->GetPhi2()); - y0 = sBh1->GetRmax1()*SinD(sBh1->GetPhi2()); - sBh2 = new TGeoArb8("ITSssdCableHoleBh2",0.5*kconZLength); - y = sBh1->GetRmax1(); - x = x0+(y-y0)/TanD(90.0+kconCableHoleAngle); - sBh2->SetVertex(0,x,y); - y = sBh1->GetRmin1()*SinD(sBh1->GetPhi2()); - x = x0+(y-y0)/TanD(90.0+kconCableHoleAngle); - sBh2->SetVertex(3,x,y); - x0 = sBh1->GetRmax1()*CosD(sBh1->GetPhi1()); - y0 = sBh1->GetRmax1()*SinD(sBh1->GetPhi1()); - y = sBh1->GetRmax1(); - x = x0+(y-y0)/TanD(90.0-kconCableHoleAngle); - sBh2->SetVertex(1,x,y); - y = sBh1->GetRmin1()*SinD(sBh1->GetPhi1()); - x = x0+(y-y0)/TanD(90.0-kconCableHoleAngle); - sBh2->SetVertex(2,x,y); - for(i=0;i<4;i++){ // define points at +dz - sAh2->SetVertex(i+4,(sAh2->GetVertices())[2*i], - (sAh2->GetVertices())[1+2*i]); - sBh2->SetVertex(i+4,(sBh2->GetVertices())[2*i], - (sBh2->GetVertices())[1+2*i]); - } // end for i - sAh3 = new TGeoBBox("ITSssdCoolingHoleAh3",0.5*kconCoolHoleWidth, - 0.5*kconCoolHoleHight,kconZLength); - sBh3 = new TGeoBBox("ITSssdCoolingHoleBh3", - 0.5*kconCoolHoleWidth+kconCthick, - 0.5*kconCoolHoleHight+kconCthick,kconZLength); - sAh4 = new TGeoBBox("ITSssdMountingPostHoleAh4",0.5*kconMountHoleWidth, - 0.5*kconMountHoleHight,0.5*kconZLength); - z = sF0->GetZ(0)-sF0->GetZ(sF0->GetNz()-1); - if(z<0.0) z = -z; - sBh4 = new TGeoBBox("ITSssdMountingPostHoleBh4", - 0.5*kconMountHoleWidth+kconCthick, - 0.5*kconMountHoleHight+kconCthick,0.5*z); - // SSD Cone Wings - sG = new TGeoConeSeg("ITSssdWingCarbonFiberSurfaceG", - 0.5*kconWingThick,kconROuterMax-kconCthick, - kconWingRmax,kconROuterMax-kconCthick,kconWingRmax, - kconWingPhi0-(0.5*kconWingWidth/kconWingRmax)*fgkRadian, - kconWingPhi0+(0.5*kconWingWidth/kconWingRmax)*fgkRadian); - sH = new TGeoConeSeg("ITSssdWingStaseliteH", - 0.5*kconWingThick-kconCthick,kconROuterMax-kconCthick, - kconWingRmax-kconCthick, - kconROuterMax-kconCthick, - kconWingRmax-kconCthick, - kconWingPhi0-((0.5*kconWingWidth-kconCthick)/ - (kconWingRmax-kconCthick))*fgkRadian, - kconWingPhi0+((0.5*kconWingWidth-kconCthick)/ - (kconWingRmax-kconCthick))*fgkRadian); - // SDD support plate, SSD side. - //Poly-cone Volume sT. - sT = new TGeoTubeSeg("ITSssdsddMountingBracketT",ksupPRmin,ksupPRmax, - ksupPZ,ksupPPhi1,ksupPPhi2); - // - TGeoRotation *rotZ225 =new TGeoRotation("ITSssdConeZ225", 0.0,0.0, 22.5); - rotZ225->RegisterYourself(); - TGeoRotation *rotZ675 =new TGeoRotation("ITSssdConeZ675", 0.0,0.0, 67.5); - rotZ675->RegisterYourself(); - TGeoRotation *rotZ90 =new TGeoRotation("ITSssdConeZ90", 0.0,0.0, 90.0); - rotZ90->RegisterYourself(); - TGeoRotation *rotZ1125=new TGeoRotation("ITSssdConeZ1125",0.0,0.0,112.5); - rotZ1125->RegisterYourself(); - TGeoRotation *rotZ1575=new TGeoRotation("ITSssdConeZ1575",0.0,0.0,157.5); - rotZ1575->RegisterYourself(); - TGeoRotation *rotZ180 =new TGeoRotation("ITSssdConeZ180", 0.0,0.0,180.0); - rotZ180->RegisterYourself(); - TGeoRotation *rotZ2025=new TGeoRotation("ITSssdConeZ2025",0.0,0.0,202.5); - rotZ2025->RegisterYourself(); - TGeoRotation *rotZ2475=new TGeoRotation("ITSssdConeZ2475",0.0,0.0,247.5); - rotZ2475->RegisterYourself(); - TGeoRotation *rotZ270 =new TGeoRotation("ITSssdConeZ270", 0.0,0.0,270.0); - rotZ270->RegisterYourself(); - TGeoRotation *rotZ2925=new TGeoRotation("ITSssdConeZ2925",0.0,0.0,292.5); - rotZ2925->RegisterYourself(); - TGeoRotation *rotZ3375=new TGeoRotation("ITSssdConeZ3375",0.0,0.0,337.5); - rotZ3375->RegisterYourself(); - // - vl[0] = 0.0;vl[1] = kconCoolHoleRmin+0.5*kconCoolHoleHight;vl[2] = 0.0; - rotZ225->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA225 = new TGeoCombiTrans("ITSssdConeTZ225",vg[0], - vg[1],vg[2],rotZ225); - rotranA225->RegisterYourself(); - rotZ675->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA675 = new TGeoCombiTrans("ITSssdConeTZ675", vg[0], - vg[1],vg[2],rotZ675); - rotranA675->RegisterYourself(); - rotZ1125->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA1125 = new TGeoCombiTrans("ITSssdConeTZ1125",vg[0], - vg[1],vg[2],rotZ1125); - rotranA1125->RegisterYourself(); - rotZ1575->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA1575 = new TGeoCombiTrans("ITSssdConeTZ1575",vg[0], - vg[1],vg[2],rotZ1575); - rotranA1575->RegisterYourself(); - rotZ2025->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA2025 = new TGeoCombiTrans("ITSssdConeTZ2025",vg[0], - vg[1],vg[2],rotZ2025); - rotranA2025->RegisterYourself(); - rotZ2475->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA2475 = new TGeoCombiTrans("ITSssdConeTZ2475",vg[0], - vg[1],vg[2],rotZ2475); - rotranA2475->RegisterYourself(); - rotZ2925->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA2925 = new TGeoCombiTrans("ITSssdConeTZ2925",vg[0], - vg[1],vg[2],rotZ2925); - rotranA2925->RegisterYourself(); - rotZ3375->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA3375 = new TGeoCombiTrans("ITSssdConeTZ3375",vg[0], - vg[1],vg[2],rotZ3375); - rotranA3375->RegisterYourself(); - TGeoRotation *rotZ30 = new TGeoRotation("ITSssdConeZ30", 0.0,0.0, 30.0); - TGeoRotation *rotZ60 = new TGeoRotation("ITSssdConeZ60", 0.0,0.0, 60.0); - //TGeoRotation *rotZ120 = new TGeoRotation("ITSssdConeZ120",0.0,0.0,120.0); - TGeoRotation *rotZ150 = new TGeoRotation("ITSssdConeZ150",0.0,0.0,150.0); - TGeoRotation *rotZ210 = new TGeoRotation("ITSssdConeZ210",0.0,0.0,210.0); - //TGeoRotation *rotZ240 = new TGeoRotation("ITSssdConeZ240",0.0,0.0,240.0); - TGeoRotation *rotZ300 = new TGeoRotation("ITSssdConeZ300",0.0,0.0,300.0); - TGeoRotation *rotZ330 = new TGeoRotation("ITSssdConeZ330",0.0,0.0,330.0); - vl[0] = kconMountHoleRmin+0.5*kconMountHoleHight; vl[1] = 0.0; vl[2] = 0.0; - for(i=0;iGetNz();i++) vl[2] += sF0->GetZ(i); - vl[2] /= (Double_t)(sF0->GetNz()); - rotZ30->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA30 = new TGeoCombiTrans("ITSssdConeTZ30",vg[0], - vg[1],vg[2],rotZ30); - rotranA30->RegisterYourself(); - rotZ90->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA90 = new TGeoCombiTrans("ITSssdConeTZ90", vg[0], - vg[1],vg[2],rotZ90); - rotranA90->RegisterYourself(); - rotZ150->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA150 = new TGeoCombiTrans("ITSssdConeTZ150",vg[0], - vg[1],vg[2],rotZ150); - rotranA150->RegisterYourself(); - rotZ210->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA210 = new TGeoCombiTrans("ITSssdConeTZ210",vg[0], - vg[1],vg[2],rotZ210); - rotranA210->RegisterYourself(); - rotZ270->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA270 = new TGeoCombiTrans("ITSssdConeTZ270",vg[0], - vg[1],vg[2],rotZ270); - rotranA270->RegisterYourself(); - rotZ330->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranA330 = new TGeoCombiTrans("ITSssdConeTZ330",vg[0], - vg[1],vg[2],rotZ330); - rotranA330->RegisterYourself(); - vl[0] = 0.0; vl[1] = 0.0; vl[2] = sA0->GetZ(10)+sT->GetDz(); - rotZ60->LocalToMaster(vl,vg); - TGeoCombiTrans *rotranBrTZ60 = new TGeoCombiTrans("ITSssdConeBrTZ60", - vg[0],vg[1],vg[2],rotZ60); - rotranBrTZ60->RegisterYourself(); - TGeoCombiTrans *rotranBrTZ180 = new TGeoCombiTrans("ITSssdConeBrTZ180", - vg[0],vg[1],vg[2],rotZ180); - rotranBrTZ180->RegisterYourself(); - TGeoCombiTrans *rotranBrTZ300 = new TGeoCombiTrans("ITSssdConeBrTZ300", - vg[0],vg[1],vg[2],rotZ300); - rotranBrTZ300->RegisterYourself(); - if(AliDebugLevel()){ - rotZ225->Print(); - rotZ675->Print(); - rotZ90->Print(); - rotZ1125->Print(); - rotZ1575->Print(); - rotZ180->Print(); - rotZ2025->Print(); - rotZ2475->Print(); - rotZ270->Print(); - rotZ2925->Print(); - rotZ3375->Print(); - rotranA225->Print(); - rotranA675->Print(); - rotranA1125->Print(); - rotranA1575->Print(); - rotranA2025->Print(); - rotranA2475->Print(); - rotranA2925->Print(); - rotranA3375->Print(); - rotZ60->Print(); - rotZ300->Print(); - rotranA30->Print(); - rotranA90->Print(); - rotranA150->Print(); - rotranA210->Print(); - rotranA270->Print(); - rotranA330->Print(); - rotranBrTZ60->Print(); - rotranBrTZ180->Print(); - rotranBrTZ300->Print(); - } // end if AliDebugLevel() - sA = new TGeoCompositeShape("ITSssdSuportConeCarbonFiberSurfaceA", - "((((((((((((((((((((((((((((" - "ITSssdSuportConeCarbonFiberSurfaceA0 +" - "ITSssdWingCarbonFiberSurfaceG) +" - "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ90) +" - "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ180) +" - "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ270) -" - "(ITSssdCableHoleAh1:ITSssdConeZ225*ITSssdCableHoleAh2:ITSssdConeZ225)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ675*ITSssdCableHoleAh2:ITSssdConeZ675)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ1125*ITSssdCableHoleAh2:ITSssdConeZ1125)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ1575*ITSssdCableHoleAh2:ITSssdConeZ1575)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ2025*ITSssdCableHoleAh2:ITSssdConeZ2025)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ2475*ITSssdCableHoleAh2:ITSssdConeZ2475)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ2925*ITSssdCableHoleAh2:ITSssdConeZ2925)) -" - "(ITSssdCableHoleAh1:ITSssdConeZ3375*ITSssdCableHoleAh2:ITSssdConeZ3375)) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ225) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ675) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ1125) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ1575) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ2025) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ2475) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ2925) -" - "ITSssdCoolingHoleAh3:ITSssdConeTZ3375) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ30) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ90) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ150) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ210) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ270) -" - "ITSssdMountingPostHoleAh4:ITSssdConeTZ330) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ60) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ180) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ300" - ); - sB = new TGeoCompositeShape("ITSssdSuportConeStaseliteB", - "((((((((((((((((((((((((((((" - "ITSssdSuportConeStaseliteB0 +" - "ITSssdWingStaseliteH) +" - "ITSssdWingStaseliteH:ITSssdConeZ90) +" - "ITSssdWingStaseliteH:ITSssdConeZ180) +" - "ITSssdWingStaseliteH:ITSssdConeZ270) -" - "(ITSssdCableHoleBh1:ITSssdConeZ225*ITSssdCableHoleBh2:ITSssdConeZ225)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ675*ITSssdCableHoleBh2:ITSssdConeZ675)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ1125*ITSssdCableHoleBh2:ITSssdConeZ1125)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ1575*ITSssdCableHoleBh2:ITSssdConeZ1575)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ2025*ITSssdCableHoleBh2:ITSssdConeZ2025)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ2475*ITSssdCableHoleBh2:ITSssdConeZ2475)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ2925*ITSssdCableHoleBh2:ITSssdConeZ2925)) -" - "(ITSssdCableHoleBh1:ITSssdConeZ3375*ITSssdCableHoleBh2:ITSssdConeZ3375)) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ225) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ675) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ1125) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ1575) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ2025) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ2475) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ2925) -" - "ITSssdCoolingHoleBh3:ITSssdConeTZ3375) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ30) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ90) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ150) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ210) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ270) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ330) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ60) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ180) -" - "ITSssdsddMountingBracketT:ITSssdConeBrTZ300" - ); - sC = new TGeoCompositeShape("ITSssdSuportConeRohacellC", - "(((((((" - "ITSssdSuportConeRohacellC0 -" - "ITSssdCableHoleBh1:ITSssdConeZ225*ITSssdCableHoleBh2:ITSssdConeZ225) -" - "ITSssdCableHoleBh1:ITSssdConeZ675*ITSssdCableHoleBh2:ITSssdConeZ675) -" - "ITSssdCableHoleBh1:ITSssdConeZ1125*ITSssdCableHoleBh2:ITSssdConeZ1125) -" - "ITSssdCableHoleBh1:ITSssdConeZ1575*ITSssdCableHoleBh2:ITSssdConeZ1575) -" - "ITSssdCableHoleBh1:ITSssdConeZ2025*ITSssdCableHoleBh2:ITSssdConeZ2025) -" - "ITSssdCableHoleBh1:ITSssdConeZ2475*ITSssdCableHoleBh2:ITSssdConeZ2475) -" - "ITSssdCableHoleBh1:ITSssdConeZ2925*ITSssdCableHoleBh2:ITSssdConeZ2925) -" - "ITSssdCableHoleBh1:ITSssdConeZ3375*ITSssdCableHoleBh2:ITSssdConeZ3375 " - ); - sF = new TGeoCompositeShape("ITSssdSuportConeRohacellCF", - "(((((" - "ITSssdSuportConeRohacellCF0 -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ30) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ90) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ150) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ210) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ270) -" - "ITSssdMountingPostHoleBh4:ITSssdConeTZ330" - ); - // - // In volume SCB, th Inserto Stesalite 4411w material volume, there - // are a number of Stainless steel screw and pin studs which will be - // filled with screws/studs. - sD = new TGeoTube("ITS Screw+stud used to mount things to the SSD " - "support cone", - 0.0,kconRScrewM5by12,kconLScrewM5by12); - sE = new TGeoTube("ITS pin used to mount things to the " - "SSD support cone",0.0,kconRPinO6,kconLPinO6); - // Bolt heads holding the SSD-SDD tube to the SSD cone. - // Bolt -- PolyCone - //Poly-cone Volume sQ. - sQ = new TGeoPcon("ITS SSD Thermal sheal M6 screw headQ",0.0,360.0,4); - sQ->Z(0) = sA0->GetZ(12); - sQ->Rmin(0) = 0.0; - sQ->Rmax(0) = kcylRM6; - sQ->Z(1) = sQ->GetZ(0) - kconZM6Head; - sQ->Rmin(1) = 0.0; - sQ->Rmax(1) = kcylRM6; - sQ->Z(2) = sQ->GetZ(1); - sQ->Rmin(2) = 0.0; - sQ->Rmax(2) = kconRM6Head; - sQ->Z(3) = sQ->GetZ(0)-ksupPZ; - sQ->Rmin(3) = 0.0; - sQ->Rmax(3) = 0.5*kconRM6Head; - // air infront of bolt (stasolit Volume K) -- Tube - sR = new TGeoTube("ITS Air in front of bolt (in stasolit)R", - sQ->GetRmin(3),sQ->GetRmax(3),0.5*(ksupPZ-kconCthick)); - // air infront of bolt (carbon fiber volume I) -- Tube - sS = new TGeoTube("ITS Air in front of Stainless Steal Screw end, M6S", - sQ->GetRmin(3),sQ->GetRmax(3),0.5*kconCthick); - // - if(AliDebugLevel()){ - sA0->InspectShape(); - sB0->InspectShape(); - sC0->InspectShape(); - sF0->InspectShape(); - sQ->InspectShape(); - sAh1->InspectShape(); - sBh1->InspectShape(); - sAh2->InspectShape(); - sBh2->InspectShape(); - sAh3->InspectShape(); - sBh3->InspectShape(); - sAh4->InspectShape(); - sBh4->InspectShape(); - sG->InspectShape(); - sH->InspectShape(); - sT->InspectShape(); - sD->InspectShape(); - sE->InspectShape(); - sR->InspectShape(); - sS->InspectShape(); - sA->InspectShape(); - sB->InspectShape(); - sC->InspectShape(); - sF->InspectShape(); - } // end if AliDebugLevel() - TGeoVolume *vA,*vB,*vC,*vD,*vE,*vF,*vQ,*vR,*vS,*vT; - // - vA = new TGeoVolume("ITSssdConeA",sA,medSSDcf); // Carbon Fiber - vA->SetVisibility(kTRUE); - vA->SetLineColor(4); // blue - vA->SetLineWidth(1); - vA->SetFillColor(vA->GetLineColor()); - vA->SetFillStyle(4050); // 50% transparent - vB = new TGeoVolume("ITSssdConeB",sB,medSSDfs); // Staselite - vB->SetVisibility(kTRUE); - vB->SetLineColor(2); // red - vB->SetLineWidth(1); - vB->SetFillColor(vB->GetLineColor()); - vB->SetFillStyle(4050); // 50% transparent - vC = new TGeoVolume("ITSssdConeC",sC,medSSDfo); // Rohacell - vC->SetVisibility(kTRUE); - vC->SetLineColor(3); // green - vC->SetLineWidth(1); - vC->SetFillColor(vC->GetLineColor()); - vC->SetFillStyle(4050); // 50% transparent - vF = new TGeoVolume("ITSssdConeF",sF,medSSDfo); // Rohacell; - vF->SetVisibility(kTRUE); - vF->SetLineColor(3); // green - vF->SetLineWidth(1); - vF->SetFillColor(vF->GetLineColor()); - vF->SetFillStyle(4050); // 50% transparent - vD = new TGeoVolume("ITSssdConeD",sD,medSSDss); - vD->SetVisibility(kTRUE); - vD->SetLineColor(1); // black - vD->SetLineWidth(1); - vD->SetFillColor(vD->GetLineColor()); - vD->SetFillStyle(4000); // 0% transparent - vE = new TGeoVolume("ITSssdConeE",sE,medSSDss); - vE->SetVisibility(kTRUE); - vE->SetLineColor(1); // black - vE->SetLineWidth(1); - vE->SetFillColor(vE->GetLineColor()); - vE->SetFillStyle(4000); // 0% transparent - vQ = new TGeoVolume("ITSssdConeQ",sQ,medSSDss); - vQ->SetVisibility(kTRUE); - vQ->SetLineColor(1); // black - vQ->SetLineWidth(1); - vQ->SetFillColor(vQ->GetLineColor()); - vQ->SetFillStyle(4000); // 0% transparent - vR = new TGeoVolume("ITSssdConeR",sR,medSSDair); - vR->SetVisibility(kTRUE); - vR->SetLineColor(5); // yellow - vR->SetLineWidth(1); - vR->SetFillColor(vR->GetLineColor()); - vR->SetFillStyle(4090); // 90% transparent - vS = new TGeoVolume("ITSssdConeS",sS,medSSDair); - vS->SetVisibility(kTRUE); - vS->SetLineColor(5); // yellow - vS->SetLineWidth(1); - vS->SetFillColor(vS->GetLineColor()); - vS->SetFillStyle(4090); // 90% transparent - vT = new TGeoVolume("ITSssdsddMountingBracket",sT,medSSDal); - vT->SetVisibility(kTRUE); - vT->SetLineColor(5); // yellow - vT->SetLineWidth(1); - vT->SetFillColor(vT->GetLineColor()); - vT->SetFillStyle(4000); // 0% transparent - // - TGeoCombiTrans *rotran; - TGeoTranslation *tran; - tran = new TGeoTranslation("ITSssdConeTrans",0.0,0.0,-kconZDisplacement); - TGeoRotation *rotY180 = new TGeoRotation("",0.0,180.0,0.0); - TGeoCombiTrans *flip = new TGeoCombiTrans("ITSssdConeFlip", - 0.0,0.0,kconZDisplacement,rotY180); - delete rotY180;// rot not explicity used in AddNode functions. - // - // - // - // - vA->AddNode(vB,1,0); - vB->AddNode(vC,1,0); - vB->AddNode(vF,1,0); - moth->AddNode(vA,1,tran); // RB24 side - moth->AddNode(vA,2,flip); // RB26 side (Absorber) - // - // - // - // Insert Bolt and Pins in both the Cone and Cylinder at the same time. - Int_t nCopyCDv=0,nCopyCEv=0,nCopyQv=0,nCopyvR=0,nCopySv=0,nCopyTv=0; - Int_t nCopyvD=0,nCopyvE=0; - z = sCB->GetZ(0)-0.5*kcylZPin; - dt = (360.0/((Double_t)kcylNPin)); - for(i=0;iAddNode(vCD,++nCopyCDv,tran); - tran = new TGeoTranslation("",x,y,-z); - vCB->AddNode(vCD,++nCopyCDv,tran); - } // end for i - dt = (360.0/((Double_t)kcylNM6)); - for(i=0;iGetZ(0)-0.5*kcylZM6; - tran = new TGeoTranslation("",x,y,z); - vCB->AddNode(vCE,++nCopyCEv,tran); - tran = new TGeoTranslation("",x,y,-z); - vCB->AddNode(vCE,++nCopyCEv,tran); - tran = new TGeoTranslation("",x,y,0.0); - vB->AddNode(vQ,++nCopyQv,tran); - if(!((tGetRotation()->GetPhiRotation()+sT->GetPhi2()&& - t>rotranBrTZ60->GetRotation()->GetPhiRotation()-sT->GetPhi1())|| - (tGetRotation()->GetPhiRotation()+sT->GetPhi2()&& - t>rotranBrTZ180->GetRotation()->GetPhiRotation()-sT->GetPhi1())|| - (tGetRotation()->GetPhiRotation()+sT->GetPhi2()&& - t>rotranBrTZ300->GetRotation()->GetPhiRotation()-sT->GetPhi1()))){ - // If not at an angle where the bracket sT is located. - tran = new TGeoTranslation("",x,y,sB0->GetZ(10)-sR->GetDz()); - vB->AddNode(vR,++nCopyvR,tran); - tran = new TGeoTranslation("",x,y,sA0->GetZ(10)-sS->GetDz()); - vA->AddNode(vS,++nCopySv,tran); - } // end if - } // end for i - // Add the mounting brackets to the RB24 side only. - vl[0] = 0.0; - vl[1] = 0.0; - vl[2] = sA0->GetZ(10)+kconZDisplacement-sT->GetDz(); - rotZ60->LocalToMaster(vl,vg); - rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ60); - moth->AddNode(vT,++nCopyTv,rotran); - rotZ180->LocalToMaster(vl,vg); - rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ180); - moth->AddNode(vT,++nCopyTv,rotran); - rotZ300->LocalToMaster(vl,vg); - rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ300); - moth->AddNode(vT,++nCopyTv,rotran); - // - Double_t da[] = {-3.5,-1.5,1.5,3.5}; - for(i=0;i<2;i++){ // Mounting for ITS-TPC bracket or ITS-Rails - t0 = 180.*((Double_t)i); - for(j=-kconNScrewM5by12/2;j<=kconNScrewM5by12/2;j++)if(j!=0){ - //screws per ITS-TPC brkt - t = t0 + 5.0*((Double_t)j); - tran = new TGeoTranslation("",kconROutHoles*CosD(t), - kconROutHoles*SinD(t), - sB0->GetZ(0)+sD->GetDz()); - vB->AddNode(vD,++nCopyvD,tran); - } // end or j - for(j=-kconNPinO6/2;j<=kconNPinO6/2;j++){ // pins per ITS-TPC bracket - t = t0 + 3.0*((Double_t)j); - tran = new TGeoTranslation("",kconROutHoles*CosD(t), - kconROutHoles*SinD(t), - sB0->GetZ(0)+sD->GetDz()); - vB->AddNode(vE,++nCopyvE,tran); - } // end or j - t0 = (96.5+187.*((Double_t)i)); - for(j=0;jGetZ(0)+sD->GetDz()); - vB->AddNode(vD,++nCopyvD,tran); - } // end or j - t0 = (91.5+184.*((Double_t)i)); - for(j=-kconNRailPins/2;j<=kconNRailPins/2;j++)if(j!=0){ - // pins per ITS-rail bracket - t = t0+(7.0*((Double_t)j)); - tran = new TGeoTranslation("",kconROutHoles*CosD(t), - kconROutHoles*SinD(t), - sB0->GetZ(0)+sD->GetDz()); - vB->AddNode(vE,++nCopyvE,tran); - } // end or j - } // end for i - for(i=0;iGetZ(0)+sD->GetDz()); - vB->AddNode(vD,++nCopyvD,tran); - } // end for j - for(j=0;j<1;j++){ // 1 pin per bracket - t = t0; - tran = new TGeoTranslation("",kconROutHoles*CosD(t), - kconROutHoles*SinD(t), - sB0->GetZ(0)+sD->GetDz()); - vB->AddNode(vE,++nCopyvE,tran); - } // end for j - } // end for i - if(AliDebugLevel()){ - vA->PrintNodes(); - vB->PrintNodes(); - vC->PrintNodes(); - vD->PrintNodes(); - vE->PrintNodes(); - vF->PrintNodes(); - vQ->PrintNodes(); - vR->PrintNodes(); - vS->PrintNodes(); - vT->PrintNodes(); - } // end if +TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA( + const Double_t trayLen, + const Double_t trayHi){ +// +// Creates parts of the SDD and SSD Trays on Side A which are identical +// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11) +// +// Input: +// trayLen : the length of the tray part +// trayHi : the height of the tray part +// +// Output: +// +// Return: a TGeoXtru +// +// Created: 26 Feb 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings, L.Simonetti technical +// drawings and other (oral) information given by F.Tosello +// + + // Dimensions and positions of the A-Side Cable Trays + // (parts of 0872/G/C) + const Double_t kTrayWidth = 130.00 *fgkmm; + const Double_t kTrayWingWidth = 10.00 *fgkmm; + const Double_t kTrayHeightToBend = 20.00 *fgkmm; + const Double_t kTrayThick = 2.00 *fgkmm; + + const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad(); + + const Int_t kTrayNpoints = 16; + + // Local variables + Double_t xprof[kTrayNpoints], yprof[kTrayNpoints]; + + + // The tray shape: a Xtru + TGeoXtru *trayPart = new TGeoXtru(2); + + xprof[2] = kTrayWidth/2 - kTrayThick; + yprof[2] = trayHi - kTrayThick; + xprof[3] = kTrayWidth/2 - kTrayWingWidth; + yprof[3] = yprof[2]; + xprof[4] = xprof[3]; + yprof[4] = trayHi; + xprof[5] = kTrayWidth/2; + yprof[5] = yprof[4]; + xprof[6] = xprof[5]; + yprof[6] = kTrayHeightToBend; + xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle); + yprof[7] = 0; + + InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7], + -kTrayThick, xprof[1], yprof[1]); + + xprof[8] = -xprof[7]; + yprof[8] = yprof[7]; + + InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8], + -kTrayThick, xprof[0], yprof[0]); + + // We did the right side, now reflex on the left side + for (Int_t jp = 0; jp < 8; jp++) { + xprof[8+jp] = -xprof[7-jp]; + yprof[8+jp] = yprof[7-jp]; + } + + // And now the actual Xtru + trayPart->DefinePolygon(kTrayNpoints, xprof, yprof); + trayPart->DefineSection(0, 0); + trayPart->DefineSection(1, trayLen); + + + return trayPart; } //______________________________________________________________________ -void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth){ - // Define the detail ITS cable support trays on both the RB24 and - // RB26 sides.. - // Inputs: - // TGeo Volume *moth The mother volume to place this object. - // Outputs: - // none. - // Return: - // none. - // Based on the Drawings SSup_201A.jpg unless otherwise stated, - // Volumes A..., - TGeoMedium *medSUPcf = 0; // SUP support cone Carbon Fiber materal nbr. - TGeoMedium *medSUPfs = 0; // SUP support cone inserto stesalite 4411w. - TGeoMedium *medSUPfo = 0; // SUP support cone foam, Rohacell 50A. - TGeoMedium *medSUPss = 0; // SUP support cone screw material,Stainless - TGeoMedium *medSUPair = 0; // SUP support cone Air - TGeoMedium *medSUPal = 0; // SUP support cone SDD mounting bracket Al - TGeoMedium *medSUPwater = 0; // SUP support cone Water - TGeoManager *mgr = gGeoManager; - medSUPcf = mgr->GetMedium("ITSssdCarbonFiber"); - medSUPfs = mgr->GetMedium("ITSssdStaselite4411w"); - medSUPfo = mgr->GetMedium("ITSssdRohacell50A"); - medSUPss = mgr->GetMedium("ITSssdStainlessSteal"); - medSUPair = mgr->GetMedium("ITSssdAir"); - medSUPal = mgr->GetMedium("ITSssdAl"); - medSUPwater = mgr->GetMedium("ITSssdWater"); - // - Int_t i,j; - Double_t x,y,z,t,t0,dt,di,r,l,local[3],master[3]; - Char_t name[100]; - Double_t r1,r2,m; - // RB 24, Open Side. - const Double_t kfrm24Z0 = 900*fgkmm;//SSup_203A.jpg - const Double_t kfrm24Thss = 5.0*fgkmm; - const Double_t kfrm24Rss = 444.5*fgkmm-kfrm24Thss; //SSup_204A.jpg - const Double_t kfrm24Width = 10.0*fgkmm; - const Double_t kfrm24Hight = 10.0*fgkmm; - const Double_t kfrm24Phi0 = 15.2*fgkDegree; // SSup_602A.jpg - const Double_t kfrm24Phi1 = (90.0-7.6)*fgkDegree; // SSup_802A.jpg - const Double_t kfrm24ZssSection = (415.0-10.0)*fgkmm; - const Int_t kfrm24NZsections = 4; - const Int_t kfrm24NPhiSections = 4; - const Int_t kfrm24NPhi = 4; - // These numbers are guessed at. - const Double_t kfrm24ZfracAngle = 0.55; // frational z length to brack - const Double_t kfrm24Angle = 10.0*fgkDegree; // Guessed at - // - TGeoTubeSeg *sA24[kfrm24NZsections+1]; - TGeoArb8 *sB24[kfrm24NZsections+1]; - TGeoPcon *sM24; - Double_t zA24[kfrm24NZsections+1]; - l = 4.*kfrm24ZssSection+5*kfrm24Width; - j = 0; - for(i=0;il*kfrm24ZfracAngle){ // break, radii get larger - r1 = kfrm24Rss + (zA24[i]-kfrm24ZfracAngle*l)*SinD(kfrm24Angle); - } // end if - r2 = r1+kfrm24Thss; - sA24[i] = new TGeoTubeSeg(name,r1,r2,0.5*kfrm24Width,kfrm24Phi0, - kfrm24Phi1); - if(i>0)if(sA24[i-1]->GetRmin()==sA24[i]->GetRmin()) j = i; - } // end for i - for(i=0;iSetVertex(0,sA24[i]->GetRmin(),0.5*kfrm24Hight); - sB24[i]->SetVertex(1,sA24[i]->GetRmax(),0.5*kfrm24Hight); - sB24[i]->SetVertex(2,sA24[i]->GetRmin(),-0.5*kfrm24Hight); - sB24[i]->SetVertex(3,sA24[i]->GetRmax(),-0.5*kfrm24Hight); - sB24[i]->SetVertex(4,sA24[i+1]->GetRmin(),0.5*kfrm24Hight); - sB24[i]->SetVertex(5,sA24[i+1]->GetRmax(),0.5*kfrm24Hight); - sB24[i]->SetVertex(6,sA24[i+1]->GetRmin(),-0.5*kfrm24Hight); - sB24[i]->SetVertex(7,sA24[i+1]->GetRmax(),-0.5*kfrm24Hight); - } // end for i - sM24 = new TGeoPcon("ITS sup Cable tray support frame mother volume M24", - kfrm24Phi0,kfrm24Phi1,3); - sM24->Z(0) = zA24[0] -kfrm24Width; - sM24->Rmin(0) = sA24[0]->GetRmin(); - sM24->Rmax(0) = sA24[0]->GetRmax(); - sM24->Z(1) = zA24[j]; - sM24->Rmin(1) = sA24[j]->GetRmin(); - sM24->Rmax(1) = sA24[j]->GetRmax(); - sM24->Z(2) = zA24[kfrm24NZsections] + kfrm24Width; - sM24->Rmin(2) = sA24[kfrm24NZsections]->GetRmin(); - sM24->Rmax(2) = sA24[kfrm24NZsections]->GetRmax(); - if(AliDebugLevel()){ - sM24->InspectShape(); - for(i=0;iInspectShape(); - for(i=0;iInspectShape(); - } // end if AliDebugLevel() - TGeoVolume *vA24[kfrm24NZsections+1],*vB24[kfrm24NZsections],*vM24; - TGeoTranslation *tran; - TGeoRotation *rot,*rot1; - TGeoCombiTrans *tranrot; - // - for(i=0;iSetVisibility(kTRUE); - vA24[i]->SetLineColor(1); // black - vA24[i]->SetLineWidth(1); - vA24[i]->SetFillColor(vA24[i]->GetLineColor()); - vA24[i]->SetFillStyle(4000); // 0% transparent - } // end for i - for(i=0;iSetVisibility(kTRUE); - vB24[i]->SetLineColor(1); // black - vB24[i]->SetLineWidth(1); - vB24[i]->SetFillColor(vB24[i]->GetLineColor()); - vB24[i]->SetFillStyle(4000); // 0% transparent - } // end for i - vM24 = new TGeoVolume("ITSsupFrameM24",sM24,medSUPair); - vM24->SetVisibility(kTRUE); - vM24->SetLineColor(7); // light blue - vM24->SetLineWidth(1); - vM24->SetFillColor(vM24->GetLineColor()); - vM24->SetFillStyle(4090); // 90% transparent - // - Int_t ncopyB24[kfrm24NPhiSections]; - t0 = kfrm24Phi0; - dt = (kfrm24Phi1-kfrm24Phi0)/((Double_t)kfrm24NPhiSections); - for(i=0;i<=kfrm24NZsections;i++){ - z = zA24[i]; - tran = new TGeoTranslation("",0.0,0.0,z); - vM24->AddNode(vA24[i],1,tran); - if(iGetDz(),rot); - delete rot;// rot not explicity used in AddNode functions. - vM24->AddNode(vB24[i],ncopyB24[i]++,tranrot); - } // end for j - } // end if - } // end for i - tran = new TGeoTranslation("",0.0,0.0,kfrm24Z0); - moth->AddNode(vM24,1,tran); - for(i=1;iAddNode(vM24,i+1,tranrot); - } // end for i - if(AliDebugLevel()){ - for(i=0;iPrintNodes(); - for(i=0;iPrintNodes(); - vM24->PrintNodes(); - } // end if - //================================================================== - // RB24 Cable Tray - const Double_t kct24WidthBottom = 44.0*fgkmm; // Serv-C_208.jpg - const Double_t kct24WidthTop = 46.0*fgkmm; // Serv-C_208.jpg - const Double_t kct24Hight = 51.0*fgkmm; // Serv-C_208.jpg - const Double_t kct24AlThick = 1.0*fgkmm; // Serv-C_208.jpg - const Double_t kct24CapWidth = 46.0*fgkmm; // Serv-C_208.jpg - const Double_t kct24CapEar = 5.0*fgkmm; // Guess - const Double_t kct24Rmin = 455.0*fgkmm; // Serv-C_203.jpg - const Double_t kct24CoolSectionH = 470.0*fgkmm-kct24Rmin;// Serv-C_203.jpg - const Double_t kct24CoolCableDivEar = 2.0*fgkmm; // Guess - const Int_t kct24Ntrays = 48; // Serv-C_205.jpg - //const Int_t kct24Ntubes = 3; // Serv-C_208.jpg - // Patch Pannels for RB 24 side - const Double_t kft24PPHightSPDFMD = 72.0*fgkmm; // Serv-C_SPD/FMD.jpg - const Double_t kft24PPHightSDDSSD = 104.0*fgkmm; // Serv-C_SDD/SSD.jpg - const Double_t kft24PPlength = 350.0*fgkmm;//Serv-C_SPD/SDD/SSD/FMD_1.jpg - const Double_t kft24Theta = 2.0*TMath::ATan2(kct24WidthBottom, - 2.0*kct24Rmin)*fgkRadian; // - const Int_t kft24NPatchPannels = 20; // - // - Double_t xp[12],yp[12]; - TGeoPcon *sMT24; - TGeoXtru *sT24,*sTs24,*sTl24,*sTt24,*sU24,*sVl24,*sVs24,*sW24; - TGeoXtru *s3PP24,*s2PP24,*sV3PP24,*sV2PP24; - // Outer Tray Full - sT24 = new TGeoXtru(3); - sT24->SetName("ITS sup Full Cable Tray for RB24 Side T24"); - xp[0] = -0.5*kct24WidthBottom; - yp[0] = sM24->GetRmax(0); - yp[1] = yp[0] + kct24Hight-kct24CapEar; - xp[1] = Xfrom2Points(xp[0],yp[0],-0.5*kct24WidthTop+kct24AlThick, - yp[0]+kct24Hight,yp[1]); - yp[2] = yp[1]; - xp[2] = xp[1]-kct24AlThick; - xp[3] = -0.5*kct24CapWidth; - yp[3] = yp[0] + kct24Hight; - xp[4] = -xp[3]; - yp[4] = yp[3]; - xp[5] = -xp[2]; - yp[5] = yp[2]; - xp[6] = -xp[1]; - yp[6] = yp[1]; - xp[7] = -xp[0]; - yp[7] = yp[0]; - sT24->DefinePolygon(8,xp,yp); - sT24->DefineSection(0,sM24->GetZ(0)); - sT24->DefineSection(1,sM24->GetZ(1)); - sT24->DefineSection(2,zA24[kfrm24NZsections],0.0, - sA24[kfrm24NZsections]->GetRmin()-sA24[0]->GetRmin()); - // RB 24 full tray no divider (for ALG and T0-V0 cables?) - sW24 = new TGeoXtru(3); - sW24->SetName("ITS sup Cable Tray No Divider for RB24 Side W24"); - xp[0] = sT24->GetX(0) + kct24AlThick; - yp[0] = sT24->GetY(0) - kct24AlThick; - yp[1] = sT24->GetY(3) - kct24AlThick; - xp[1] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1), - sT24->GetY(1),yp[1]) + kct24AlThick; - xp[2] = -xp[1]; - yp[2] = yp[1]; - xp[3] = -xp[0]; - yp[3] = yp[0]; - sW24->DefinePolygon(4,xp,yp); - for(i=0;iGetNz();i++){ - sW24->DefineSection(i,sT24->GetZ(i),sT24->GetXOffset(i), - sT24->GetYOffset(i),sT24->GetScale(i)); - } // end for i - // Outer Tray Short - sTs24 = new TGeoXtru(3); - sTs24->SetName("ITS sup Short Cable Tray for RB24 Side Ts24"); - yp[0] = sT24->GetY(0) + kct24CoolSectionH; - xp[0] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1), - sT24->GetY(1),yp[0]); - for(i=1;i<7;i++){ - xp[i] = sT24->GetX(i); - yp[i] = sT24->GetY(i); - } // end for i - xp[7] = -xp[0]; - yp[7] = yp[0]; - sTs24->DefinePolygon(8,xp,yp); - sTs24->DefineSection(0,sM24->GetZ(0)+kft24PPlength); - sTs24->DefineSection(1,sM24->GetZ(1)); - sTs24->DefineSection(2,zA24[kfrm24NZsections],sT24->GetXOffset(2), - sT24->GetYOffset(2),sT24->GetScale(2)); - // Outer Tray Long - sTl24 = new TGeoXtru(3); - sTl24->SetName("ITS sup Long Cable Tray for RB24 Side Tl24"); - for(i=0;i<8;i++){ - xp[i] = sTs24->GetX(i); - yp[i] = sTs24->GetY(i); - } // End for i - sTl24->DefinePolygon(8,xp,yp); - sTl24->DefineSection(0,sM24->GetZ(0)); - sTl24->DefineSection(1,sM24->GetZ(1)); - sTl24->DefineSection(2,zA24[kfrm24NZsections],0.0, - sA24[kfrm24NZsections]->GetRmin()-sA24[0]->GetRmin()); - // Outer Tray for air Tubes - sTt24 = new TGeoXtru(3); - sTt24->SetName("ITS sup Long Air Tube Tray for RB24 Side Tt24"); - xp[0] = sT24->GetX(0); - yp[0] = sT24->GetY(0); - xp[1] = sTl24->GetX(0); - yp[1] = sTl24->GetY(0); - xp[2] = -xp[1]; - yp[2] = yp[1]; - xp[3] = -xp[0]; - yp[3] = yp[1]; - sTt24->DefinePolygon(4,xp,yp); - sTt24->DefineSection(0,sM24->GetZ(0)); - sTt24->DefineSection(1,sM24->GetZ(1)); - sTt24->DefineSection(2,zA24[kfrm24NZsections],0.0, - sA24[kfrm24NZsections]->GetRmin()-sA24[0]->GetRmin()); - // Inner opening for cooling (lower) {inside sTt24} - sU24 = new TGeoXtru(3); - sU24->SetName("ITS sup Cable Tray Cooling tube space RB24 Side U24"); - xp[0] = sTt24->GetX(0) + kct24AlThick; - yp[0] = sTt24->GetY(0) + kct24AlThick; - xp[1] = sTt24->GetX(1) + kct24AlThick; - yp[1] = sTt24->GetY(1) - kct24AlThick; - xp[2] = -xp[1]; - yp[2] = yp[1]; - xp[3] = -xp[0]; - yp[3] = yp[0]; - sU24->DefinePolygon(4,xp,yp); - for(i=0;iGetNz();i++){ - sU24->DefineSection(i,sTt24->GetZ(i),sTt24->GetXOffset(i), - sTt24->GetYOffset(i),sTt24->GetScale(i)); - } // end for i - // Inner opening for cables (upper) {inside sTl24} - sVl24 = new TGeoXtru(3); - sVl24->SetName("ITS sup Cable Tray Cable space RB24 Side Vl24"); - xp[0] = sTl24->GetX(0)+2.0*kct24AlThick; - yp[0] = sTl24->GetY(0); - yp[1] = yp[0] + kct24CoolCableDivEar; - xp[1] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0), - sTl24->GetX(1),sTl24->GetY(1),yp[1])+2.0*kct24AlThick; - yp[2] = yp[1]; - xp[2] = xp[1] - kct24AlThick; - yp[3] = sTl24->GetY(3) - kct24AlThick; - xp[3] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0),sTl24->GetX(1), - sTl24->GetY(1),yp[3]) + kct24AlThick; - xp[4] = -xp[3]; - yp[4] = yp[3]; - xp[5] = -xp[2]; - yp[5] = yp[2]; - xp[6] = -xp[1]; - yp[6] = yp[1]; - xp[7] = -xp[0]; - yp[7] = yp[0]; - sVl24->DefinePolygon(8,xp,yp); - for(i=0;iGetNz();i++){ - sVl24->DefineSection(i,sTl24->GetZ(i),sTl24->GetXOffset(i), - sTl24->GetYOffset(i),sTl24->GetScale(i)); - } // end for i - // Inner opening for cables (upper) {inside sTs24} - sVs24 = new TGeoXtru(3); - sVs24->SetName("ITS sup Cable Tray Cable space RB24 Side Vs24"); - sVs24->DefinePolygon(8,xp,yp); - for(i=0;i<8;i++){ - xp[i] = sVl24->GetX(i); - yp[i] = sVl24->GetY(i); - } // end for i - for(i=0;iGetNz();i++){ - sVs24->DefineSection(i,sTs24->GetZ(i),sTs24->GetXOffset(i), - sTs24->GetYOffset(i),sTs24->GetScale(i)); - } // end for i - //------------------------------------------------------------------ - // Patch Pannels on RB 24 Side - rot = new TGeoRotation("",0.0,0.0,-kft24Theta); // Gets Used later as well - rot1 = new TGeoRotation("",0.0,0.0,kft24Theta); // Gets Used later as well - s3PP24 = new TGeoXtru(2); - s3PP24->SetName("ITS sup 3 bay pach pannel RB24 side 3PP24"); - yp[5] = sT24->GetY(7) + kct24CoolSectionH; - xp[5] = Xfrom2Points(sT24->GetX(7),sT24->GetY(7),sT24->GetX(6), - sT24->GetY(6),yp[6]); - yp[6] = sT24->GetY(0) + kct24CoolSectionH; - xp[6] = Xfrom2Points(sT24->GetX(0),sT24->GetY(0),sT24->GetX(1), - sT24->GetY(1),yp[9]); - local[0] = xp[6]; local[1] = yp[6]; local[2] = 0.0; - rot1->LocalToMaster(local,master); - xp[0] = master[0]; - yp[0] = master[1]; - local[0] = xp[6]; local[1] = yp[6] + kft24PPHightSDDSSD; local[2] = 0.0; - rot1->LocalToMaster(local,master); - xp[1] = master[0]; - yp[1] = master[1]; - xp[2] = -xp[1]; - yp[2] = yp[1]; - xp[3] = -xp[0]; - yp[3] = yp[0]; - local[0] = xp[6]; local[1] = yp[6]; local[2] = 0.0; - rot1->MasterToLocal(local,master); - xp[4] = master[0]; - yp[4] = master[1]; - local[0] = xp[5]; local[1] = yp[5]; local[2] = 0.0; - rot1->LocalToMaster(local,master); - xp[7] = master[0]; - yp[7] = master[1]; - s3PP24->DefinePolygon(8,xp,yp); - s3PP24->DefineSection(0,0.0); - s3PP24->DefineSection(1,kft24PPlength); - // - s2PP24 = new TGeoXtru(2); - s2PP24->SetName("ITS sup 2 bay pach pannel RB24 side 2PP24"); - local[1] = sTl24->GetY(3); local[2] = 0.0; - local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0), - sTl24->GetX(1),sTl24->GetY(1),local[1]); - rot1->LocalToMaster(local,master); - xp[0] = master[0]; - yp[0] = master[1]; - local[1] = sTl24->GetY(3) + kft24PPHightSPDFMD; local[2] = 0.0; - local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0), - sTl24->GetX(1),sTl24->GetY(1),local[1]); - rot1->LocalToMaster(local,master); - xp[1] = master[0]; - yp[1] = master[1]; - yp[2] = sTl24->GetY(4) + kft24PPHightSPDFMD; - xp[2] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6), - sTl24->GetX(7),sTl24->GetY(7),yp[2]); - yp[3] = sTl24->GetY(7); - xp[3] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6), - sTl24->GetX(7),sTl24->GetY(7),yp[3]); - xp[4] = sTl24->GetX(3); - yp[4] = sTl24->GetY(3); - local[0] = sTl24->GetX(4);local[1] = sTl24->GetY(4); local[2] = 0.0; - rot1->LocalToMaster(local,master); - xp[5] = master[0]; - yp[5] = master[1]; - s2PP24->DefinePolygon(6,xp,yp); - s2PP24->DefineSection(0,0.0); - s2PP24->DefineSection(1,kft24PPlength); - // - sV3PP24 = new TGeoXtru(2); - sV3PP24->SetName("ITS sup Patch Pannel 3 Bay inside Rb24 side V3PP24"); - xp[0] = s3PP24->GetX(0) + kct24AlThick; - yp[0] = s3PP24->GetY(0); - local[1] = s3PP24->GetY(6) + kft24PPHightSDDSSD - kct24AlThick;local[2]=0.; - local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0), - sTl24->GetX(1),sTl24->GetY(1),local[1]); - rot1->LocalToMaster(local,master); - xp[1] = master[0]; - yp[1] = master[1]; - xp[2] = -xp[1]; - yp[2] = yp[1]; - xp[3] = -xp[0]; - yp[3] = yp[0]; - xp[4] = s3PP24->GetX(4); - yp[4] = s3PP24->GetY(4); - xp[5] = s3PP24->GetX(5); - yp[5] = s3PP24->GetY(5); - xp[6] = s3PP24->GetX(6); - yp[6] = s3PP24->GetY(6); - xp[7] = s3PP24->GetX(7); - yp[7] = s3PP24->GetY(7); - sV3PP24->DefinePolygon(8,xp,yp); - sV3PP24->DefineSection(0,s3PP24->GetZ(0),s3PP24->GetXOffset(0), - s3PP24->GetYOffset(0),s3PP24->GetScale(0)); - sV3PP24->DefineSection(1,s3PP24->GetZ(1),s3PP24->GetXOffset(1), - s3PP24->GetYOffset(1),s3PP24->GetScale(1)); - // - sV2PP24 = new TGeoXtru(2); - sV2PP24->SetName("ITS sup Patch Pannel 2 Bay inside Rb24 side V2PP24"); - xp[0] = s2PP24->GetX(0) + kct24AlThick; - yp[0] = s2PP24->GetY(0); - local[1] = sTl24->GetY(3) + kft24PPHightSPDFMD - kct24AlThick;local[2]=0.; - local[0] = Xfrom2Points(sTl24->GetX(0),sTl24->GetY(0), - sTl24->GetX(1),sTl24->GetY(1),local[1]); - rot1->LocalToMaster(local,master); - xp[1] = master[0]; - yp[1] = master[1]; - yp[2] = sTl24->GetY(4) + kft24PPHightSPDFMD - kct24AlThick; - xp[2] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6), - sTl24->GetX(7),sTl24->GetY(7),yp[2]); - yp[3] = sTl24->GetY(4); - xp[3] = Xfrom2Points(sTl24->GetX(6),sTl24->GetY(6), - sTl24->GetX(7),sTl24->GetY(7),yp[3]);; - xp[4] = s2PP24->GetX(4); - yp[4] = s2PP24->GetY(4); - xp[5] = s2PP24->GetX(5); - yp[5] = s2PP24->GetY(5); - sV2PP24->DefinePolygon(6,xp,yp); - sV2PP24->DefineSection(0,s2PP24->GetZ(0),s2PP24->GetXOffset(0), - s2PP24->GetYOffset(0),s2PP24->GetScale(0)); - sV2PP24->DefineSection(1,s2PP24->GetZ(1),s2PP24->GetXOffset(1), - s2PP24->GetYOffset(1),s2PP24->GetScale(1)); - // RB 24 Tray Mother Volume - sMT24 = new TGeoPcon("ITS sup Cable Tray Mother Volume RB24 MT24", - 0.0,360.0,5); - sMT24->Z(0) = 0.0; - sMT24->Rmin(0) = sM24->GetRmax(0); - sMT24->Rmax(0) = TMath::Max(TMath::Hypot(s3PP24->GetX(1),s3PP24->GetY(1)), - TMath::Hypot(s2PP24->GetX(1),s2PP24->GetY(1))); - - sMT24->Z(1) = sMT24->GetZ(0) + kft24PPlength; - sMT24->Rmin(1) = sMT24->GetRmin(0); - sMT24->Rmax(1) = sMT24->GetRmax(0); - sMT24->Z(2) = sMT24->GetZ(1); - sMT24->Rmin(2) = sMT24->GetRmin(0); - sMT24->Rmax(2) = sMT24->GetRmax(0) - kft24PPHightSPDFMD; - - sMT24->Z(3) = sMT24->GetZ(0) + sM24->GetZ(1) - sM24->GetZ(0); - sMT24->Rmin(3) = sM24->GetRmax(1); - sMT24->Rmax(3) = TMath::Hypot(sT24->GetX(3),sT24->GetY(3)); - sMT24->Z(4) = sMT24->GetZ(0) + sM24->GetZ(2) - sM24->GetZ(0); - sMT24->Rmin(4) = sM24->GetRmax(2); - sMT24->Rmax(4) = TMath::Hypot(sT24->GetX(3)+sT24->GetXOffset(2), - sT24->GetY(3)+sT24->GetYOffset(2)); - // - if(AliDebugLevel()){ - sT24->InspectShape(); - sW24->InspectShape(); - sTl24->InspectShape(); - sTs24->InspectShape(); - sTt24->InspectShape(); - sU24->InspectShape(); - sVl24->InspectShape(); - sVs24->InspectShape(); - s3PP24->InspectShape(); - s2PP24->InspectShape(); - sV3PP24->InspectShape(); - sV2PP24->InspectShape(); - sMT24->InspectShape(); - } // end if AliDebugLevel() - // - TGeoVolume *vC24[kct24Ntrays],*vT24[kct24Ntrays],*vPP24[kft24NPatchPannels]; - TGeoVolume *vWTV024,*vW24,*vU24,*vUFMD24,*vVl24,*vVlFMD24,*vVs24,*vMT24; - TGeoVolume *vV3PP24,*vV2PP24,*vV2PPFMD24; - vMT24 = new TGeoVolume("ITSsupCableTrayMotherMT24",sMT24,medSUPair); - vMT24->SetVisibility(kTRUE); - vMT24->SetLineColor(8); // white - vMT24->SetLineWidth(1); - vMT24->SetFillColor(vMT24->GetLineColor()); - vMT24->SetFillStyle(4100); // 100% transparent - // - vU24 = new TGeoVolume("ITSsupCableTrayLowerU24",sU24,medSUPair); - vU24->SetVisibility(kTRUE); - vU24->SetLineColor(7); // light blue - vU24->SetLineWidth(1); - vU24->SetFillColor(vU24->GetLineColor()); - vU24->SetFillStyle(4090); // 90% transparent - vUFMD24 = new TGeoVolume("FMDsupCableTrayLowerU24",sU24,medSUPair); - vUFMD24->SetVisibility(kTRUE); - vUFMD24->SetLineColor(7); // light blue - vUFMD24->SetLineWidth(1); - vUFMD24->SetFillColor(vUFMD24->GetLineColor()); - vUFMD24->SetFillStyle(4090); // 90% transparent - vVl24 = new TGeoVolume("ITSsupCableTrayUpperV24",sVl24,medSUPair); - vVl24->SetVisibility(kTRUE); - vVl24->SetLineColor(7); // light blue - vVl24->SetLineWidth(1); - vVl24->SetFillColor(vVl24->GetLineColor()); - vVl24->SetFillStyle(4090); // 90% transparent - vVlFMD24 = new TGeoVolume("FMDsupCableTrayUpperVl24",sVl24,medSUPair); - vVlFMD24->SetVisibility(kTRUE); - vVlFMD24->SetLineColor(7); // light blue - vVlFMD24->SetLineWidth(1); - vVlFMD24->SetFillColor(vVlFMD24->GetLineColor()); - vVlFMD24->SetFillStyle(4090); // 90% transparent - vVs24 = new TGeoVolume("ITSsupCableTrayUpperVs24",sVs24,medSUPair); - vVs24->SetVisibility(kTRUE); - vVs24->SetLineColor(7); // light blue - vVs24->SetLineWidth(1); - vVs24->SetFillColor(vVs24->GetLineColor()); - vVs24->SetFillStyle(4090); // 90% transparent - vW24 = new TGeoVolume("ITSsupCableTrayUpperW24",sW24,medSUPair); - vW24->SetVisibility(kTRUE); - vW24->SetLineColor(7); // light blue - vW24->SetLineWidth(1); - vW24->SetFillColor(vW24->GetLineColor()); - vW24->SetFillStyle(4090); // 90% transparent - // - vWTV024 = new TGeoVolume("V0supCableTrayUpperWTV024",sW24,medSUPair); - vWTV024->SetVisibility(kTRUE); - vWTV024->SetLineColor(7); // light blue - vWTV024->SetLineWidth(1); - vWTV024->SetFillColor(vWTV024->GetLineColor()); - vWTV024->SetFillStyle(4090); // 90% transparent - // - vV3PP24 = new TGeoVolume("ITSsup3BayPachPannelInsideV3PP24",sV3PP24,medSUPair); - vV3PP24->SetVisibility(kTRUE); - vV3PP24->SetLineColor(8); // white - vV3PP24->SetLineWidth(1); - vV3PP24->SetFillColor(vV3PP24->GetLineColor()); - vV3PP24->SetFillStyle(4100); // 100% transparent - vV2PP24 = new TGeoVolume("ITSsup2BayPachPannelInsideV2PP24",sV2PP24,medSUPair); - vV2PP24->SetVisibility(kTRUE); - vV2PP24->SetLineColor(8); // white - vV2PP24->SetLineWidth(1); - vV2PP24->SetFillColor(vV2PP24->GetLineColor()); - vV2PP24->SetFillStyle(4100); // 100% transparent - vV2PPFMD24 = new TGeoVolume("FMDsup2BayPachPannelInsideV2PP24",sV2PP24,medSUPair); - vV2PPFMD24->SetVisibility(kTRUE); - vV2PPFMD24->SetLineColor(8); // white - vV2PPFMD24->SetLineWidth(1); - vV2PPFMD24->SetFillColor(vV2PPFMD24->GetLineColor()); - vV2PPFMD24->SetFillStyle(4100); // 100% transparent - // - delete rot; - delete rot1; - // - Double_t tha[kct24Ntrays],thb[kft24NPatchPannels]; - for(i=0;iAddNode(vVlFMD24,1,0); - }else if(strncmp(trayName[i],"TV0",3)==0){ - sprintf(name,"V0supCableTrayT24[%s]",trayName[i]); - vT24[i] = new TGeoVolume(name,sT24,medSUPal); - vT24[i]->AddNode(vWTV024,1,0); - }else if(strncmp(trayName[i],"ALG",3)==0){ // ITS Alignment Channel - sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]); - vT24[i] = new TGeoVolume(name,sT24,medSUPal); - vT24[i]->AddNode(vW24,1,0); - }else if(strncmp(trayName[i],"SPD",3)==0){ /*ITS SPD*/ - sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]); - vT24[i] = new TGeoVolume(name,sTl24,medSUPal); - vT24[i]->AddNode(vVl24,1,0); - }else { /*ITS*/ - sprintf(name,"ITSsupCableTrayT24[%s]",trayName[i]); - vT24[i] = new TGeoVolume(name,sTs24,medSUPal); /// replace solid - vT24[i]->AddNode(vVs24,1,0); - } // end if - vT24[i]->SetVisibility(kTRUE); - vT24[i]->SetLineColor(6); // purple - vT24[i]->SetLineWidth(1); - vT24[i]->SetFillColor(vT24[i]->GetLineColor()); - vT24[i]->SetFillStyle(4000); // 0% transparent - rot = new TGeoRotation("",0.0,0.0,tha[i]-90.0); - if(AliDebugLevel()) rot->Print(); - vMT24->AddNode(vT24[i],1,rot); - // - if(strncmp(trayName[i],"FMD",3)==0){ - sprintf(name,"FMDsupAirTubeTrayT24[%s]",airName[i]); - vC24[j] = new TGeoVolume(name,sTt24,medSUPair); - vC24[j]->AddNode(vUFMD24,1,0); - }else if(strncmp(trayName[i],"TV0",3)==0){ - continue; - }else if(strncmp(trayName[i],"ALG",3)==0){ - continue; - }else{ /*ITS*/ - sprintf(name,"ITSsupAirTubTrayT24[%s]",airName[i]); - vC24[j] = new TGeoVolume(name,sTt24,medSUPair); - vC24[j]->AddNode(vU24,1,0); - } // end if - vC24[j]->SetVisibility(kTRUE); - vC24[j]->SetLineColor(6); // purple - vC24[j]->SetLineWidth(1); - vC24[j]->SetFillColor(vC24[j]->GetLineColor()); - vC24[j]->SetFillStyle(4000); // 0% transparent - vMT24->AddNode(vC24[j++],1,rot); - } // end for i - for(i=0;iAddNode(vV2PPFMD24,1,0); - }else if(strncmp(pachName[i],"SPD",3)==0){ /*ITS SPD*/ - sprintf(name,"ITSsupPathcPannelPP24[%s]",pachName[i]); - vPP24[i] = new TGeoVolume(name,s2PP24,medSUPal); - vPP24[i]->AddNode(vV2PP24,1,0); - }else { /*ITS*/ - sprintf(name,"ITSsupPathcPannelPP24[%s]",pachName[i]); - vPP24[i] = new TGeoVolume(name,s3PP24,medSUPal); /// replace solid - vPP24[i]->AddNode(vV3PP24,1,0); - } // end if - vPP24[i]->SetVisibility(kTRUE); - vPP24[i]->SetLineColor(6); // purple - vPP24[i]->SetLineWidth(1); - vPP24[i]->SetFillColor(vPP24[i]->GetLineColor()); - vPP24[i]->SetFillStyle(4000); // 0% transparent - rot = new TGeoRotation("",0.0,0.0,thb[i]-90.0); - if(AliDebugLevel()) rot->Print(); - vMT24->AddNode(vPP24[i],1,rot); - } // end for i - tran = new TGeoTranslation("",0.0,0.0,kfrm24Z0); - moth->AddNode(vMT24,1,tran); - if(AliDebugLevel()){ - for(i=0;iPrintNodes(); - for(i=0;iPrintNodes(); - vU24->PrintNodes(); - vUFMD24->PrintNodes(); - vVl24->PrintNodes(); - vVlFMD24->PrintNodes(); - vVs24->PrintNodes(); - vW24->PrintNodes(); - vWTV024->PrintNodes(); - vMT24->PrintNodes(); - } // end if - //================================================================== - // - // RB 26, Muon Absober side - const Double_t kfrm26Z0 = -900*fgkmm;//SSup_203A.jpg - const Double_t kfrm26Thss = 5.0*fgkmm; - const Double_t kfrm26R0ss = 444.5*fgkmm-kfrm26Thss; //SSup_204A.jpg - const Double_t kfrm26R1ss = 601.6*fgkmm-kfrm26Thss; //SSup_208A.jpg - const Double_t kfrm26Width = 10.0*fgkmm; - //const Double_t kfrm26Hight = 10.0*fgkmm; - const Double_t kfrm26Phi0 = 15.2*fgkDegree; // SSup_602A.jpg - const Double_t kfrm26Phi1 = (90.0-7.6)*fgkDegree; // SSup_802A.jpg - const Double_t kfrm26ZssSection = (415.0-10.0)*fgkmm; - const Int_t kfrm26NZsections = 4; - const Int_t kfrm26NPhiSections = 4; - const Int_t kfrm26NPhi = 4; - TGeoConeSeg *sA26[kfrm26NZsections+1],*sM26;//Cylinderial support structure - TGeoArb8 *sB26; // Cylinderial support structure - - sM26 = new TGeoConeSeg("ITS sup Cable tray support frame mother volume " - "M26",0.5*(4.*kfrm26ZssSection+5*kfrm26Width), - kfrm26R1ss,kfrm26R1ss+kfrm26Thss, - kfrm26R0ss,kfrm26R0ss+kfrm26Thss, - kfrm26Phi0,kfrm26Phi1); - m = -((kfrm26R1ss-kfrm26R0ss)/ - (((Double_t)kfrm26NZsections)*(kfrm26ZssSection+kfrm26Width))); - for(i=0;iGetRmax1()+sA26[0]->GetRmin1()+ - sA26[1]->GetRmax2()+sA26[1]->GetRmin2()); - sB26->SetVertex(0,sA26[0]->GetRmax2()-r,+0.5*kfrm26Width); - sB26->SetVertex(1,sA26[0]->GetRmax2()-r,-0.5*kfrm26Width); - sB26->SetVertex(2,sA26[0]->GetRmin2()-r,-0.5*kfrm26Width); - sB26->SetVertex(3,sA26[0]->GetRmin2()-r,+0.5*kfrm26Width); - sB26->SetVertex(4,sA26[1]->GetRmax1()-r,+0.5*kfrm26Width); - sB26->SetVertex(5,sA26[1]->GetRmax1()-r,-0.5*kfrm26Width); - sB26->SetVertex(6,sA26[1]->GetRmin1()-r,-0.5*kfrm26Width); - sB26->SetVertex(7,sA26[1]->GetRmin1()-r,+0.5*kfrm26Width); - if(AliDebugLevel()){ - for(i=0;iInspectShape(); - sM26->InspectShape(); - sB26->InspectShape(); - } // end if AliDebugLevel() - // - TGeoVolume *vA26[kfrm26NZsections+1],*vB26,*vM26; - // - for(i=0;iSetVisibility(kTRUE); - vA26[i]->SetLineColor(1); // black - vA26[i]->SetLineWidth(1); - vA26[i]->SetFillColor(vA26[i]->GetLineColor()); - vA26[i]->SetFillStyle(4000); // 0% transparent - } // end for i - vB26 = new TGeoVolume("ITSsupFrameB26",sB26,medSUPss); - vB26->SetVisibility(kTRUE); - vB26->SetLineColor(1); // black - vB26->SetLineWidth(1); - vB26->SetFillColor(vB26->GetLineColor()); - vB26->SetFillStyle(4000); // 0% transparent - vM26 = new TGeoVolume("ITSsupFrameM26",sM26,medSUPair); - vM26->SetVisibility(kTRUE); - vM26->SetLineColor(7); // light blue - vM26->SetLineWidth(1); - vM26->SetFillColor(vM26->GetLineColor()); - vM26->SetFillStyle(4090); // 90% transparent - // - Int_t ncopyB26=1; - t0 = kfrm26Phi0; - dt = (kfrm26Phi1-kfrm26Phi0)/((Double_t)kfrm26NPhiSections); - for(i=0;i<=kfrm26NZsections;i++){ - di = ((Double_t) i)*(kfrm26ZssSection+kfrm26Width); - z = -sM26->GetDz()+sA26[i]->GetDz() + di; - tran = new TGeoTranslation("",0.0,0.0,z); - vM26->AddNode(vA26[i],1,tran); - z = z+sB26->GetDz(); - if(iGetRmax1()+sA26[i]->GetRmin1()+ - sA26[i+1]->GetRmax2()+sA26[i+1]->GetRmin2()); - t = t0 + ((Double_t)j)*dt; - rot = new TGeoRotation("",0.0,0.0,t); - y = r*SinD(t); - x = r*CosD(t); - tranrot = new TGeoCombiTrans("",x,y,z,rot); - delete rot; // rot not explicity used in AddNode functions. - vM26->AddNode(vB26,ncopyB26++,tranrot); - } // end for j - } // end for i - tran = new TGeoTranslation("",0.0,0.0,kfrm26Z0-sM26->GetDz()); - moth->AddNode(vM26,1,tran); - for(i=1;iAddNode(vM26,i+1,tranrot); - } // end for i - if(AliDebugLevel()){ - for(i=0;iPrintNodes(); - vB26->PrintNodes(); - vM26->PrintNodes(); - } // end if +TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC( + const char *trayName, + TGeoManager *mgr){ + +// +// Creates the SDD and SSD Trays on Side C which are supposedly identical +// +// Input: +// trayName : the assembly name +// +// Output: +// +// Return: a TGeoVolumeAssembly +// +// Created: 16 Apr 2010 Mario Sitta +// +// Technical data are taken from AutoCAD drawings and other (oral) +// information given by F.Tosello +// + + const Double_t kSideCHalfThick = 0.100 *fgkcm; + const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad(); + + const Double_t kSideCLength1 = 172.800 *fgkcm; + const Double_t kSideCLength2 = 189.300 *fgkcm; + const Double_t kSideCHalfWide = 6.350 *fgkcm; + const Double_t kSideCHeight1 = 11.800 *fgkcm; + const Double_t kSideCHeight2 = 4.300 *fgkcm; + const Double_t kSideCSideLength1 = 10.800 *fgkcm; + const Double_t kSideCSideLength2 = 63.800 *fgkcm; + const Double_t kSideCSideHeight = 8.800 *fgkcm; + const Int_t kNPointsLowerFace = 6; + const Int_t kNPointsLateralFace = 9; + + const Double_t kSideCWingAHalfLen = 5.000 *fgkcm; + const Double_t kSideCWingBHalfLen = 30.500 *fgkcm; + const Double_t kSideCWingCHalfLen = 2.000 *fgkcm; + const Double_t kSideCWingDHalfLen = 48.500 *fgkcm; + const Double_t kSideCWingEHalfLen = 83.000 *fgkcm; + const Double_t kSideCWingsHalfWide = 0.450 *fgkcm; + + const Int_t kNPointsCoverFace = 12; + + const Double_t kPlateHalfLen = 6.000 *fgkcm; + const Double_t kPlateThick = 0.600 *fgkcm; + const Double_t kPlateHeight = 4.200 *fgkcm; + const Int_t kNPointsPlate = 6; + + const Double_t kBarCoolRmax = 0.4 *fgkcm; + const Int_t kNumBarCool = 2; + const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 }; + const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 }; + + + // Local variables + Double_t xprof[12], yprof[12]; + Double_t xloc, yloc, zloc, delta, alpharot; + + // The single C-Side Cable tray as an assembly + TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName); + + // First create all needed shapes + + // The Cable Tray lower face: a Xtru + TGeoXtru *sideCLowerFace = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kSideCLength1; + yprof[1] = 0.; + xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle); + yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle); + xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle); + yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + 2*kSideCHalfThick , xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = 2*kSideCHalfThick; + + sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof); + sideCLowerFace->DefineSection(0,-kSideCHalfWide); + sideCLowerFace->DefineSection(1, kSideCHalfWide); + + // The Cable Tray lateral face: a Xtru + TGeoXtru *sideCLateralFace = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kSideCLength1; + yprof[1] = 0.; + xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle); + yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle); + xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle); + yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kSideCHeight2, xprof[4], yprof[4]); + xprof[5] = kSideCSideLength1 + kSideCSideLength2; + yprof[5] = kSideCHeight2; + xprof[6] = xprof[5]; + yprof[6] = kSideCSideHeight; + xprof[7] = kSideCSideLength1; + yprof[7] = kSideCHeight1; + xprof[8] = 0; + yprof[8] = yprof[7]; + + sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof); + sideCLateralFace->DefineSection(0,-kSideCHalfThick); + sideCLateralFace->DefineSection(1, kSideCHalfThick); + + // The lateral wings: four BBox's + TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen, + kSideCHalfThick, + kSideCWingsHalfWide); + + TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen, + kSideCHalfThick, + kSideCWingsHalfWide); + + TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these + kSideCWingCHalfLen, // X,Y avoid + kSideCWingsHalfWide);//rotations + + TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen, + kSideCHalfThick, + kSideCWingsHalfWide); + + TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen, + kSideCHalfThick, + kSideCWingsHalfWide); + + // The connecting lower plate: a Xtru + TGeoXtru *sideCLowerPlate = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kPlateHalfLen; + yprof[1] = 0.; + xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle); + yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle); + xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle); + yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kPlateThick, xprof[4], yprof[4]); + xprof[5] = 0.; + yprof[5] = kPlateThick; + + sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof); + Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick; + sideCLowerPlate->DefineSection(0,-zwide); + sideCLowerPlate->DefineSection(1, zwide); + + // The connecting side plate: a Xtru + TGeoXtru *sideCLateralPlate = new TGeoXtru(2); + + xprof[0] = 0.; + yprof[0] = 0.; + xprof[1] = kPlateHalfLen; + yprof[1] = 0.; + xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle); + yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle); + xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle); + yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle); + InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2], + kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap + xprof[5] = 0.; + yprof[5] = kPlateHeight; + + sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof); + sideCLateralPlate->DefineSection(0,-kPlateThick/2); + sideCLateralPlate->DefineSection(1, kPlateThick/2); + + // The bar fixing the cooling tubes: a Tube + TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide); + + // The Cable Tray cover: a (complex) Xtru + TGeoXtru *sideCCoverFace = new TGeoXtru(2); + + xprof[ 0] = sideCLateralFace->GetX(8); + yprof[ 0] = sideCLateralFace->GetY(8); + xprof[ 1] = sideCLateralFace->GetX(7); + yprof[ 1] = sideCLateralFace->GetY(7); + xprof[ 2] = sideCLateralFace->GetX(6); + yprof[ 2] = sideCLateralFace->GetY(6); + xprof[ 3] = sideCLateralFace->GetX(5); + yprof[ 3] = sideCLateralFace->GetY(5); + xprof[ 4] = sideCLateralFace->GetX(4); + yprof[ 4] = sideCLateralFace->GetY(4); + + xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2; + delta = kSideCLength1 - (xloc + kSideCWingDHalfLen); + xprof[ 5] = xprof[4] + + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle); + yprof[ 5] = yprof[4] + + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle); + + xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle); + yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle); + InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5], + 2*kSideCHalfThick, xprof[7], yprof[7]); + InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4], + 2*kSideCHalfThick, xprof[8], yprof[8]); + xprof[ 9] = xprof[2] + 2*kSideCHalfThick; + yprof[ 9] = yprof[2] + 2*kSideCHalfThick; + xprof[10] = xprof[1]; + yprof[10] = yprof[1] + 2*kSideCHalfThick; + xprof[11] = xprof[0]; + yprof[11] = yprof[0] + 2*kSideCHalfThick; + + sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof); + zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide; + sideCCoverFace->DefineSection(0,-zloc); + sideCCoverFace->DefineSection(1, zloc); + + + // We have all shapes: now create the real volumes + TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$"); + + TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower", + sideCLowerFace, medAl); + + traySideCLowerFace->SetVisibility(kTRUE); + traySideCLowerFace->SetLineColor(6); // Purple + traySideCLowerFace->SetLineWidth(1); + traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor()); + traySideCLowerFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral", + sideCLateralFace, medAl); + + traySideCLateralFace->SetVisibility(kTRUE); + traySideCLateralFace->SetLineColor(6); // Purple + traySideCLateralFace->SetLineWidth(1); + traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor()); + traySideCLateralFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralWingA = + new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl); + + traySideCLateralWingA->SetVisibility(kTRUE); + traySideCLateralWingA->SetLineColor(6); // Purple + traySideCLateralWingA->SetLineWidth(1); + traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor()); + traySideCLateralWingA->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralWingB = + new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl); + + traySideCLateralWingB->SetVisibility(kTRUE); + traySideCLateralWingB->SetLineColor(6); // Purple + traySideCLateralWingB->SetLineWidth(1); + traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor()); + traySideCLateralWingB->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralWingC = + new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl); + + traySideCLateralWingC->SetVisibility(kTRUE); + traySideCLateralWingC->SetLineColor(6); // Purple + traySideCLateralWingC->SetLineWidth(1); + traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor()); + traySideCLateralWingC->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralWingD = + new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl); + + traySideCLateralWingD->SetVisibility(kTRUE); + traySideCLateralWingD->SetLineColor(6); // Purple + traySideCLateralWingD->SetLineWidth(1); + traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor()); + traySideCLateralWingD->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralWingE = + new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl); + + traySideCLateralWingE->SetVisibility(kTRUE); + traySideCLateralWingE->SetLineColor(6); // Purple + traySideCLateralWingE->SetLineWidth(1); + traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor()); + traySideCLateralWingE->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLowerPlate = + new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl); + + traySideCLowerPlate->SetVisibility(kTRUE); + traySideCLowerPlate->SetLineColor(6); // Purple + traySideCLowerPlate->SetLineWidth(1); + traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor()); + traySideCLowerPlate->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCLateralPlate = + new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl); + + traySideCLateralPlate->SetVisibility(kTRUE); + traySideCLateralPlate->SetLineColor(6); // Purple + traySideCLateralPlate->SetLineWidth(1); + traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor()); + traySideCLateralPlate->SetFillStyle(4000); // 0% transparent + + TGeoVolume *traySideCCoverFace = + new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl); + + traySideCCoverFace->SetVisibility(kTRUE); + traySideCCoverFace->SetLineColor(6); // Purple + traySideCCoverFace->SetLineWidth(1); + traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor()); + traySideCCoverFace->SetFillStyle(4000); // 0% transparent + + TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar", + coolBar, medAl); + + coolingTubeBar->SetVisibility(kTRUE); + coolingTubeBar->SetLineColor(6); // Purple + coolingTubeBar->SetLineWidth(1); + coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor()); + coolingTubeBar->SetFillStyle(4000); // 0% transparent + + + // Now build up the tray + cableTrayC->AddNode(traySideCLowerFace,1,0); + + zloc = kSideCHalfWide + kSideCHalfThick; + cableTrayC->AddNode(traySideCLateralFace,1, + new TGeoTranslation(0., 0., zloc) ); + cableTrayC->AddNode(traySideCLateralFace,2, + new TGeoTranslation(0., 0.,-zloc) ); + + xloc = kSideCWingAHalfLen; + yloc = kSideCHeight1 - kSideCHalfThick; + zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide; + cableTrayC->AddNode(traySideCLateralWingA,1, + new TGeoTranslation(xloc, yloc, zloc) ); + cableTrayC->AddNode(traySideCLateralWingA,2, + new TGeoTranslation(xloc, yloc,-zloc) ); + + xloc = kSideCSideLength1 + kSideCSideLength2/2; + yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1, + kSideCSideLength1+kSideCSideLength2,kSideCSideHeight, + xloc) - kSideCHalfThick -0.0012; // Avoid small overlap + zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide; + alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )* + TMath::RadToDeg(); + cableTrayC->AddNode(traySideCLateralWingB,1, + new TGeoCombiTrans(xloc, yloc, zloc, + new TGeoRotation("",alpharot,0,0) ) ); + cableTrayC->AddNode(traySideCLateralWingB,2, + new TGeoCombiTrans(xloc, yloc,-zloc, + new TGeoRotation("",alpharot,0,0) ) ); + + xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick; + yloc = kSideCSideHeight - kSideCWingCHalfLen; + zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide; + cableTrayC->AddNode(traySideCLateralWingC,1, + new TGeoTranslation(xloc, yloc, zloc) ); + cableTrayC->AddNode(traySideCLateralWingC,2, + new TGeoTranslation(xloc, yloc,-zloc) ); + + xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2; + yloc = kSideCHeight2 - kSideCHalfThick; + zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide; + cableTrayC->AddNode(traySideCLateralWingD,1, + new TGeoTranslation(xloc, yloc, zloc) ); + cableTrayC->AddNode(traySideCLateralWingD,2, + new TGeoTranslation(xloc, yloc,-zloc) ); + + delta = kSideCLength1 - (xloc + kSideCWingDHalfLen); + xloc = kSideCLength1 + delta + kSideCWingEHalfLen; + yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) + + kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick; + zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide; + alpharot = kSideCFoldAngle*TMath::RadToDeg(); + cableTrayC->AddNode(traySideCLateralWingE,1, + new TGeoCombiTrans(xloc, yloc, zloc, + new TGeoRotation("",alpharot,0,0) ) ); + cableTrayC->AddNode(traySideCLateralWingE,2, + new TGeoCombiTrans(xloc, yloc,-zloc, + new TGeoRotation("",alpharot,0,0) ) ); + + xloc = kSideCLength1 - kPlateHalfLen; + yloc = -kPlateThick -0.0025; // Avoid small overlap + cableTrayC->AddNode(traySideCLowerPlate,1, + new TGeoTranslation(xloc, yloc, 0.) ); + + xloc = kSideCLength1 - kPlateHalfLen; + yloc = -kPlateThick; + zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2; + cableTrayC->AddNode(traySideCLateralPlate,1, + new TGeoTranslation(xloc, yloc, zloc) ); + cableTrayC->AddNode(traySideCLateralPlate,2, + new TGeoTranslation(xloc, yloc,-zloc) ); + + for (Int_t jc = 0; jc AddNode(coolingTubeBar,jc+1, + new TGeoTranslation(xloc, yloc, 0.) ); + } + + cableTrayC->AddNode(traySideCCoverFace,1,0); + + + // Finally return what we made up + + return cableTrayC; } +