* provided "as is" without express or implied warranty. *
**************************************************************************/
+// This class Defines the Geometry for the ITS services and support cones
+// outside of the ceneteral volume (except for the Ceneteral support
+// cylinders. Other classes define the rest of the ITS. Specificaly the ITS
+// The SSD support cone,SSD Support centeral cylinder, SDD support cone,
+// The SDD cupport centeral cylinder, the SPD Thermal Sheald, The supports
+// and cable trays on both the RB26 (muon dump) and RB24 sides, and all of
+// the cabling from the ladders/stave ends out past the TPC.
+
/* $Id$ */
-#include <stdio.h>
-#include <stdlib.h>
// General Root includes
-#include <Riostream.h>
#include <TMath.h>
-#include <float.h>
-#include <TFile.h> // only required for Tracking function?
-#include <TObjArray.h>
-#include <TClonesArray.h>
-#include <TLorentzVector.h>
-#include <TObjString.h>
// Root Geometry includes
+//#include <AliLog.h>
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TGeoPcon.h>
#include <TGeoCone.h>
#include <TGeoTube.h> // contaings TGeoTubeSeg
#include <TGeoArb8.h>
+#include <TGeoXtru.h>
#include <TGeoCompositeShape.h>
#include <TGeoMatrix.h>
-#include <TGeoNode.h>
-#include <TGeoMaterial.h>
-#include <TGeoMedium.h>
-#include "AliITSBaseGeometry.h"
#include "AliITSv11GeometrySupport.h"
ClassImp(AliITSv11GeometrySupport)
#define SQ(A) (A)*(A)
//______________________________________________________________________
-void AliITSv11GeometrySupport::SPDCone(TGeoVolume *Moth){
- // Define the detail SPD support cone geometry.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
- SPDThermalSheald(Moth);
+void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,const 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
+// Updated: 20 Mar 2012 Mario Sitta Reimplemented with simpler shapes
+// Updated: 20 Jul 2012 Mario Sitta Reimplemented with Composite Shape
+// Updated: 12 Oct 2012 Mario Sitta Composite Shape also for EndCap
+//
+// Technical data are taken from: ALICE-Thermal Screen "Cone transition"
+// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
+// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)
+
+
+ // Dimensions of the Central shield
+ const Double_t kHalfLengthCentral = 399.9*fgkmm;
+ const Double_t kThicknessCentral = 0.4*fgkmm;
+ const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
+ const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
+ const Double_t 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;
+ const Double_t kCoolManifHoleWid = 24.0*fgkmm; // TO BE CHECKED!
+ const Double_t kCoolManifHoleLen = 57.5*fgkmm; // 54.2 + 1.5*2 + 0.3 toll.
+ const Double_t kCoolManifHoleZPos = 36.47*fgkcm;// MUST match SPD class
+ const Double_t kCoolSuppHoleWid = 15.0*fgkmm;
+ const Double_t kCoolSuppHoleLen = 38.4*fgkmm; // 35.1 + 1.5*2 + 0.3 toll.// TO BE CHECKED!
+ const Double_t kCoolSuppHoleZPos = 26.5*fgkcm;
+ // Dimensions of the EndCap shield
+ const Double_t kHalfLengthEndCap = 25.*fgkmm;
+ const Double_t kThicknessEndCap = 2.0*fgkmm;
+ const Double_t 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 filler blocks and bars
+ const Double_t kFillerBlockLength = 20.0*fgkmm;
+ const Double_t kFillerBlockHoleR = 2.4*fgkmm;
+ const Double_t kFillerBlockZTrans = 1.5*fgkmm;
+ const Double_t kFillerBarLength = 220.0*fgkmm;
+ const Double_t kFillerBarThick = 1.0*fgkmm;
+ // Dimensions of the Flange's Ring and Wing
+ const Double_t kHalfLengthRing = 7.5*fgkmm;
+ const Double_t kThicknessRing = 0.3*fgkmm;
+ const Double_t 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 kThetaDeg = 36.0;
+ const Double_t kTheta = kThetaDeg*TMath::DegToRad();
+ const Double_t kThicknessOmega = 0.3*fgkmm;
+
+ // Local variables
+ Double_t xpos, ypos, zpos;
+ Double_t xXtru[24], yXtru[24];
+ Double_t xshld[24], yshld[24]; // Coord. of external thermal shape
+ Double_t xair[24] , yair[24]; // Coord. of whole air shape
+ Double_t xomega[48], yomega[48];
+
+
+ // 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 Composite Shape of carbon fiber.
+ // We need Composite Shapes because we have holes in which the SPD
+ // cooling manifolds and their supports will be placed.
+ // All Composite elements are XTru shapes
+
+ // First determine the external shape points
+ CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
+ kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
+ kTheta,xshld,yshld);
+
+ // 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]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally create the single Xtru volumes
+ TGeoXtru *uppershape = new TGeoXtru(2);
+ uppershape->SetName("upTS");
+
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xair[11-j];
+ yXtru[j ] = yair[11-j];
+ xXtru[j+6] = xshld[j+6];
+ yXtru[j+6] = yshld[j+6];
+ }
+ yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
+
+ uppershape->DefinePolygon(24,xXtru,yXtru);
+ uppershape->DefineSection(0,-kHalfLengthCentral);
+ uppershape->DefineSection(1, kHalfLengthCentral);
+
+ TGeoXtru *lowershape = new TGeoXtru(2);
+ lowershape->SetName("lwTS");
+
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xshld[j];
+ yXtru[j ] = yshld[j];
+ xXtru[j+6] = xair[5-j];
+ yXtru[j+6] = yair[5-j];
+ }
+ yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
+
+ lowershape->DefinePolygon(24,xXtru,yXtru);
+ lowershape->DefineSection(0,-kHalfLengthCentral);
+ lowershape->DefineSection(1, kHalfLengthCentral);
+
+ yomega[10] = yshld[6]; // Add also base thickness
+ yomega[11] = yomega[10];
+ yomega[36] = yshld[17];
+ yomega[37] = yomega[36];
+
+ TGeoXtru *omegashape = new TGeoXtru(2);
+ omegashape->SetName("omTS");
+
+ omegashape->DefinePolygon(48,xomega,yomega);
+ omegashape->DefineSection(0,-kHalfLengthCentral);
+ omegashape->DefineSection(1, kHalfLengthCentral);
+
+ // And now the holes and their position matrices
+ Double_t radius = 0.5*(uppershape->GetY(11)+lowershape->GetY(0));
+
+ TGeoBBox *manifhole = new TGeoBBox(kCoolManifHoleWid/2,
+ 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
+ kCoolManifHoleLen/2);
+ manifhole->SetName("mhTS");
+
+ zpos = kCoolManifHoleZPos;
+
+ TGeoTranslation *m1p = new TGeoTranslation("m1p",0,radius, zpos);
+ TGeoTranslation *m1n = new TGeoTranslation("m1n",0,radius,-zpos);
+ m1p->RegisterYourself();
+ m1n->RegisterYourself();
+
+ TGeoCombiTrans *m2p = new TGeoCombiTrans("m2p",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ TGeoCombiTrans *m2n = new TGeoCombiTrans("m2n",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ m2p->RegisterYourself();
+ m2n->RegisterYourself();
+
+ TGeoCombiTrans *m3p = new TGeoCombiTrans("m3p",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ TGeoCombiTrans *m3n = new TGeoCombiTrans("m3n",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ -zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ m3p->RegisterYourself();
+ m3n->RegisterYourself();
+
+ TGeoCombiTrans *m4p = new TGeoCombiTrans("m4p",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ TGeoCombiTrans *m4n = new TGeoCombiTrans("m4n",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ m4p->RegisterYourself();
+ m4n->RegisterYourself();
+
+ TGeoCombiTrans *m5p = new TGeoCombiTrans("m5p",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ TGeoCombiTrans *m5n = new TGeoCombiTrans("m5n",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ m5p->RegisterYourself();
+ m5n->RegisterYourself();
+
+ TGeoBBox *supphole = new TGeoBBox(kCoolSuppHoleWid/2,
+ 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
+ kCoolSuppHoleLen/2);
+ supphole->SetName("shTS");
+
+ zpos = kCoolSuppHoleZPos;
+
+ TGeoTranslation *s1p = new TGeoTranslation("s1p",0,radius, zpos);
+ TGeoTranslation *s1n = new TGeoTranslation("s1n",0,radius,-zpos);
+ s1p->RegisterYourself();
+ s1n->RegisterYourself();
+
+ TGeoCombiTrans *s2p = new TGeoCombiTrans("s2p",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ TGeoCombiTrans *s2n = new TGeoCombiTrans("s2n",radius*SinD(kThetaDeg),
+ radius*CosD(kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-kThetaDeg,0,0));
+ s2p->RegisterYourself();
+ s2n->RegisterYourself();
+
+ TGeoCombiTrans *s3p = new TGeoCombiTrans("s3p",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ TGeoCombiTrans *s3n = new TGeoCombiTrans("s3n",radius*SinD(-kThetaDeg),
+ radius*CosD(-kThetaDeg),
+ -zpos,
+ new TGeoRotation("",kThetaDeg,0,0));
+ s3p->RegisterYourself();
+ s3n->RegisterYourself();
+
+ TGeoCombiTrans *s4p = new TGeoCombiTrans("s4p",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ TGeoCombiTrans *s4n = new TGeoCombiTrans("s4n",radius*SinD(2*kThetaDeg),
+ radius*CosD(2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0));
+ s4p->RegisterYourself();
+ s4n->RegisterYourself();
+
+ TGeoCombiTrans *s5p = new TGeoCombiTrans("s5p",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ TGeoCombiTrans *s5n = new TGeoCombiTrans("s5n",radius*SinD(-2*kThetaDeg),
+ radius*CosD(-2*kThetaDeg),
+ -zpos,
+ new TGeoRotation("",2*kThetaDeg,0,0));
+ s5p->RegisterYourself();
+ s5n->RegisterYourself();
+
+ // Finally the actual shape
+ TGeoCompositeShape *centralshape = new TGeoCompositeShape("centralTS",
+ "upTS+lwTS+omTS-mhTS:m1p-mhTS:m1n-mhTS:m2p-mhTS:m2n-mhTS:m3p-mhTS:m3n-mhTS:m4p-mhTS:m4n-mhTS:m5p-mhTS:m5n-shTS:s1p-shTS:s1n-shTS:s2p-shTS:s2n-shTS:s3p-shTS:s3n-shTS:s4p-shTS:s4n-shTS:s5p-shTS:s5n");
+
+ // The end cap half shield: a Composite Shape of carbon fiber.
+ // We need Composite Shapes because we have elements partially
+ // entering the empty spaces, and this would create overlaps or
+ // extrusions.
+ // All Composite elements are XTru shapes
+
+ // First determine the external shape points
+ CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
+ kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
+ kTheta,xshld,yshld);
+
+ // 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]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally create the single Xtru volumes
+ TGeoXtru *upendcapshape = new TGeoXtru(2);
+ upendcapshape->SetName("upEC");
+
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xair[11-j];
+ yXtru[j ] = yair[11-j];
+ xXtru[j+6] = xshld[j+6];
+ yXtru[j+6] = yshld[j+6];
+ }
+ yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
+
+ upendcapshape->DefinePolygon(24,xXtru,yXtru);
+ upendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ upendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ TGeoXtru *lowendcapshape = new TGeoXtru(2);
+ lowendcapshape->SetName("lwEC");
+
+ for (Int_t j=0; j<6; j++) {
+ xXtru[j ] = xshld[j];
+ yXtru[j ] = yshld[j];
+ xXtru[j+6] = xair[5-j];
+ yXtru[j+6] = yair[5-j];
+ }
+ yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
+ for (Int_t j=0; j<12; j++) {
+ xXtru[23-j] = -xXtru[j];
+ yXtru[23-j] = yXtru[j];
+ }
+
+ lowendcapshape->DefinePolygon(24,xXtru,yXtru);
+ lowendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ lowendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ yomega[10] = yshld[6]; // Add also base thickness
+ yomega[11] = yomega[10];
+ yomega[36] = yshld[17];
+ yomega[37] = yomega[36];
+
+ TGeoXtru *omgendcapshape = new TGeoXtru(2);
+ omgendcapshape->SetName("omEC");
+
+ omgendcapshape->DefinePolygon(48,xomega,yomega);
+ omgendcapshape->DefineSection(0,-kHalfLengthEndCap);
+ omgendcapshape->DefineSection(1, kHalfLengthEndCap);
+
+ // Finally the actual shape
+ TGeoCompositeShape *endcapshape = new TGeoCompositeShape("endcapTS",
+ "upEC+lwEC+omEC");
+
+ // The filler block: a Xtru
+ TGeoXtru *fillershape = new TGeoXtru(2);
+
+ xXtru[0] = omgendcapshape->GetX(1) + 0.0002; // Avoid thiny extrusion
+ yXtru[0] = omgendcapshape->GetY(1);
+ xXtru[1] = omgendcapshape->GetX(0) + 0.0002;
+ yXtru[1] = omgendcapshape->GetY(0);
+ xXtru[2] = omgendcapshape->GetX(47) - 0.0002;
+ yXtru[2] = omgendcapshape->GetY(47);
+ xXtru[3] = omgendcapshape->GetX(46);
+ yXtru[3] = omgendcapshape->GetY(46);
+
+ fillershape->DefinePolygon(4,xXtru,yXtru);
+ fillershape->DefineSection(0,-kFillerBlockLength/2);
+ fillershape->DefineSection(1, kFillerBlockLength/2);
+
+ // The hole in the filler: a Tube (made of air)
+ TGeoTube *fillerholeshape = new TGeoTube(0, kFillerBlockHoleR,
+ kFillerBlockLength/2);
+
+ // The filler bar: a BBox
+ Double_t fside = omgendcapshape->GetY(14) - omgendcapshape->GetY(13);
+ TGeoBBox *fillbarshape = new TGeoBBox(fside/2, fside/2, kFillerBarLength/2);
+
+ // The hole in the bar filler: a smaller BBox (made of air)
+ fside -= 2*kFillerBarThick;
+ TGeoBBox *fillbarholeshape = new TGeoBBox(fside/2, fside/2,
+ kFillerBarLength/2);
+
+ // The cone half shield is more complex since there is no basic
+ // TGeo shape to describe it correctly. So it is a Composite Shape
+ // of a series of TGeoArb8 shapes, in which TGeoArb8 shapes filled
+ // with air are placed, which all together make up the cone AND
+ // its internal insert. Part of the following code is adapted from
+ // old SPDThermalSheald method.
+
+ // sCn : Filled portions, sChn : Air holes
+ TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC3 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC4 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC5 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC6 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC7 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC8 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC9 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone);
+
+ sC1->SetName("sC1");
+ sC2->SetName("sC2");
+ sC3->SetName("sC3");
+ sC4->SetName("sC4");
+ sC5->SetName("sC5");
+ sC6->SetName("sC6");
+ sC7->SetName("sC7");
+ sC8->SetName("sC8");
+ sC9->SetName("sC9");
+ sC10->SetName("sC10");
+ sC11->SetName("sC11");
+
+ TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh3 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh4 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh5 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh6 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh7 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh8 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh9 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone);
+ TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone);
+
+ sCh1->SetName("sCh1");
+ sCh2->SetName("sCh2");
+ sCh3->SetName("sCh3");
+ sCh4->SetName("sCh4");
+ sCh5->SetName("sCh5");
+ sCh6->SetName("sCh6");
+ sCh7->SetName("sCh7");
+ sCh8->SetName("sCh8");
+ sCh9->SetName("sCh9");
+ sCh10->SetName("sCh10");
+ sCh11->SetName("sCh11");
+
+ // Smaller end: determine the coordinates of the points of carbon fiber
+ CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
+ kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
+ kTheta,xshld,yshld);
+
+ sC1->SetVertex(0, xshld[12], yshld[12]);
+ sC1->SetVertex(1, xshld[11], yshld[11]);
+ sC1->SetVertex(2, xshld[ 0], yshld[ 0]);
+ sC1->SetVertex(3, xshld[23], yshld[23]);
+
+ sC2->SetVertex(0, xshld[11], yshld[11]);
+ sC2->SetVertex(1, xshld[10], yshld[10]);
+ sC2->SetVertex(2, xshld[ 1], yshld[ 1]);
+ sC2->SetVertex(3, xshld[ 0], yshld[ 0]);
+
+ sC3->SetVertex(0, xshld[10], yshld[10]);
+ sC3->SetVertex(1, xshld[ 9], yshld[ 9]);
+ sC3->SetVertex(2, xshld[ 2], yshld[ 2]);
+ sC3->SetVertex(3, xshld[ 1], yshld[ 1]);
+
+ sC4->SetVertex(0, xshld[ 9], yshld[ 9]);
+ sC4->SetVertex(1, xshld[ 8], yshld[ 8]);
+ sC4->SetVertex(2, xshld[ 3], yshld[ 3]);
+ sC4->SetVertex(3, xshld[ 2], yshld[ 2]);
+
+ sC5->SetVertex(0, xshld[ 8], yshld[ 8]);
+ sC5->SetVertex(1, xshld[ 7], yshld[ 7]);
+ sC5->SetVertex(2, xshld[ 4], yshld[ 4]);
+ sC5->SetVertex(3, xshld[ 3], yshld[ 3]);
+
+ sC6->SetVertex(0, xshld[ 7], yshld[ 7]);
+ sC6->SetVertex(1, xshld[ 6], yshld[ 6]);
+ sC6->SetVertex(2, xshld[ 5], yshld[ 5]);
+ sC6->SetVertex(3, xshld[ 4], yshld[ 4]);
+
+ sC7->SetVertex(0,-xshld[10], yshld[10]);
+ sC7->SetVertex(1,-xshld[11], yshld[11]);
+ sC7->SetVertex(2,-xshld[ 0], yshld[ 0]);
+ sC7->SetVertex(3,-xshld[ 1], yshld[ 1]);
+
+ sC8->SetVertex(0,-xshld[ 9], yshld[ 9]);
+ sC8->SetVertex(1,-xshld[10], yshld[10]);
+ sC8->SetVertex(2,-xshld[ 1], yshld[ 1]);
+ sC8->SetVertex(3,-xshld[ 2], yshld[ 2]);
+
+ sC9->SetVertex(0,-xshld[ 8], yshld[ 8]);
+ sC9->SetVertex(1,-xshld[ 9], yshld[ 9]);
+ sC9->SetVertex(2,-xshld[ 2], yshld[ 2]);
+ sC9->SetVertex(3,-xshld[ 3], yshld[ 3]);
+
+ sC10->SetVertex(0,-xshld[ 7], yshld[ 7]);
+ sC10->SetVertex(1,-xshld[ 8], yshld[ 8]);
+ sC10->SetVertex(2,-xshld[ 3], yshld[ 3]);
+ sC10->SetVertex(3,-xshld[ 4], yshld[ 4]);
+
+ sC11->SetVertex(0,-xshld[ 6], yshld[ 6]);
+ sC11->SetVertex(1,-xshld[ 7], yshld[ 7]);
+ sC11->SetVertex(2,-xshld[ 4], yshld[ 4]);
+ sC11->SetVertex(3,-xshld[ 5], yshld[ 5]);
+
+ // Then rescale to get the air volume dimensions
+ InsidePoint(xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0],
+ xshld[ 1], yshld[ 1], kThicknessCone,
+ xair[0], yair[0]);
+ for (Int_t i=1; i<23; i++) {
+ InsidePoint(xshld[i-1], yshld[i-1],
+ xshld[ i ], yshld[ i ],
+ xshld[i+1], yshld[i+1], kThicknessCone,
+ xair[i], yair[i]);
+ }
+ InsidePoint(xshld[22], yshld[22],
+ xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0], kThicknessCone,
+ xair[23], yair[23]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally fill the small end coordinates of the air shapes
+ sCh1->SetVertex(0, xomega[ 0], yomega[ 0]);
+ sCh1->SetVertex(1, xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]);
+
+ sCh2->SetVertex(0, xomega[20], yomega[20]);
+ sCh2->SetVertex(1, xomega[21], yomega[21]);
+ sCh2->SetVertex(2, xomega[22], yomega[22]);
+ sCh2->SetVertex(3, xomega[23], yomega[23]);
+
+ sCh3->SetVertex(0, xomega[ 2], yomega[ 2]);
+ sCh3->SetVertex(1, xomega[ 3], yomega[ 3]);
+ sCh3->SetVertex(2, xomega[ 4], yomega[ 4]);
+ sCh3->SetVertex(3, xomega[ 5], yomega[ 5]);
+
+ sCh4->SetVertex(0, xomega[16], yomega[16]);
+ sCh4->SetVertex(1, xomega[17], yomega[17]);
+ sCh4->SetVertex(2, xomega[18], yomega[18]);
+ sCh4->SetVertex(3, xomega[19], yomega[19]);
+
+ sCh5->SetVertex(0, xomega[ 6], yomega[ 6]);
+ sCh5->SetVertex(1, xomega[ 7], yomega[ 7]);
+ sCh5->SetVertex(2, xomega[ 8], yomega[ 8]);
+ sCh5->SetVertex(3, xomega[ 9], yomega[ 9]);
+
+ sCh6->SetVertex(0, xomega[12], yomega[12]);
+ sCh6->SetVertex(1, xomega[13], yomega[13]);
+ sCh6->SetVertex(2, xomega[14], yomega[14]);
+ sCh6->SetVertex(3, xomega[15], yomega[15]);
+
+ sCh7->SetVertex(0,-xomega[21], yomega[21]);
+ sCh7->SetVertex(1,-xomega[20], yomega[20]);
+ sCh7->SetVertex(2,-xomega[23], yomega[23]);
+ sCh7->SetVertex(3,-xomega[22], yomega[22]);
+
+ sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]);
+ sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]);
+ sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]);
+ sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]);
+
+ sCh9->SetVertex(0,-xomega[17], yomega[17]);
+ sCh9->SetVertex(1,-xomega[16], yomega[16]);
+ sCh9->SetVertex(2,-xomega[19], yomega[19]);
+ sCh9->SetVertex(3,-xomega[18], yomega[18]);
+
+ sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]);
+ sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]);
+ sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]);
+ sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]);
+
+ sCh11->SetVertex(0,-xomega[13], yomega[13]);
+ sCh11->SetVertex(1,-xomega[12], yomega[12]);
+ sCh11->SetVertex(2,-xomega[15], yomega[15]);
+ sCh11->SetVertex(3,-xomega[14], yomega[14]);
+
+ // Bigger end: determine the coordinates of the points of carbon fiber
+
+ // Drawings give only the radius, convert it to the apothegm
+ Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
+ - 0.25*kInnerACone*kInnerACone);
+ Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
+ - 0.25*kOuterACone*kOuterACone);
+
+ CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
+ kOuterACone,kOuterBCone,kOuterRadiusCone,
+ kTheta,xshld,yshld);
+
+ sC1->SetVertex(4, xshld[12], yshld[12]);
+ sC1->SetVertex(5, xshld[11], yshld[11]);
+ sC1->SetVertex(6, xshld[ 0], yshld[ 0]);
+ sC1->SetVertex(7, xshld[23], yshld[23]);
+
+ sC2->SetVertex(4, xshld[11], yshld[11]);
+ sC2->SetVertex(5, xshld[10], yshld[10]);
+ sC2->SetVertex(6, xshld[ 1], yshld[ 1]);
+ sC2->SetVertex(7, xshld[ 0], yshld[ 0]);
+
+ sC3->SetVertex(4, xshld[10], yshld[10]);
+ sC3->SetVertex(5, xshld[ 9], yshld[ 9]);
+ sC3->SetVertex(6, xshld[ 2], yshld[ 2]);
+ sC3->SetVertex(7, xshld[ 1], yshld[ 1]);
+
+ sC4->SetVertex(4, xshld[ 9], yshld[ 9]);
+ sC4->SetVertex(5, xshld[ 8], yshld[ 8]);
+ sC4->SetVertex(6, xshld[ 3], yshld[ 3]);
+ sC4->SetVertex(7, xshld[ 2], yshld[ 2]);
+
+ sC5->SetVertex(4, xshld[ 8], yshld[ 8]);
+ sC5->SetVertex(5, xshld[ 7], yshld[ 7]);
+ sC5->SetVertex(6, xshld[ 4], yshld[ 4]);
+ sC5->SetVertex(7, xshld[ 3], yshld[ 3]);
+
+ sC6->SetVertex(4, xshld[ 7], yshld[ 7]);
+ sC6->SetVertex(5, xshld[ 6], yshld[ 6]);
+ sC6->SetVertex(6, xshld[ 5], yshld[ 5]);
+ sC6->SetVertex(7, xshld[ 4], yshld[ 4]);
+
+ sC7->SetVertex(4,-xshld[10], yshld[10]);
+ sC7->SetVertex(5,-xshld[11], yshld[11]);
+ sC7->SetVertex(6,-xshld[ 0], yshld[ 0]);
+ sC7->SetVertex(7,-xshld[ 1], yshld[ 1]);
+
+ sC8->SetVertex(4,-xshld[ 9], yshld[ 9]);
+ sC8->SetVertex(5,-xshld[10], yshld[10]);
+ sC8->SetVertex(6,-xshld[ 1], yshld[ 1]);
+ sC8->SetVertex(7,-xshld[ 2], yshld[ 2]);
+
+ sC9->SetVertex(4,-xshld[ 8], yshld[ 8]);
+ sC9->SetVertex(5,-xshld[ 9], yshld[ 9]);
+ sC9->SetVertex(6,-xshld[ 2], yshld[ 2]);
+ sC9->SetVertex(7,-xshld[ 3], yshld[ 3]);
+
+ sC10->SetVertex(4,-xshld[ 7], yshld[ 7]);
+ sC10->SetVertex(5,-xshld[ 8], yshld[ 8]);
+ sC10->SetVertex(6,-xshld[ 3], yshld[ 3]);
+ sC10->SetVertex(7,-xshld[ 4], yshld[ 4]);
+
+ sC11->SetVertex(4,-xshld[ 6], yshld[ 6]);
+ sC11->SetVertex(5,-xshld[ 7], yshld[ 7]);
+ sC11->SetVertex(6,-xshld[ 4], yshld[ 4]);
+ sC11->SetVertex(7,-xshld[ 5], yshld[ 5]);
+
+ // Then rescale to get the air volume dimensions
+ InsidePoint(xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0],
+ xshld[ 1], yshld[ 1], kThicknessCone,
+ xair[0], yair[0]);
+ for (Int_t i=1; i<23; i++) {
+ InsidePoint(xshld[i-1], yshld[i-1],
+ xshld[ i ], yshld[ i ],
+ xshld[i+1], yshld[i+1], kThicknessCone,
+ xair[i], yair[i]);
+ }
+ InsidePoint(xshld[22], yshld[22],
+ xshld[23], yshld[23],
+ xshld[ 0], yshld[ 0], kThicknessCone,
+ xair[23], yair[23]);
+
+ // Then use them to determine the Omega shape points
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
+
+ // Finally fill the big end coordinates of the air shapes
+ sCh1->SetVertex(4, xomega[ 0], yomega[ 0]);
+ sCh1->SetVertex(5, xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]);
+ sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]);
+
+ sCh2->SetVertex(4, xomega[20], yomega[20]);
+ sCh2->SetVertex(5, xomega[21], yomega[21]);
+ sCh2->SetVertex(6, xomega[22], yomega[22]);
+ sCh2->SetVertex(7, xomega[23], yomega[23]);
+
+ sCh3->SetVertex(4, xomega[ 2], yomega[ 2]);
+ sCh3->SetVertex(5, xomega[ 3], yomega[ 3]);
+ sCh3->SetVertex(6, xomega[ 4], yomega[ 4]);
+ sCh3->SetVertex(7, xomega[ 5], yomega[ 5]);
+
+ sCh4->SetVertex(4, xomega[16], yomega[16]);
+ sCh4->SetVertex(5, xomega[17], yomega[17]);
+ sCh4->SetVertex(6, xomega[18], yomega[18]);
+ sCh4->SetVertex(7, xomega[19], yomega[19]);
+
+ sCh5->SetVertex(4, xomega[ 6], yomega[ 6]);
+ sCh5->SetVertex(5, xomega[ 7], yomega[ 7]);
+ sCh5->SetVertex(6, xomega[ 8], yomega[ 8]);
+ sCh5->SetVertex(7, xomega[ 9], yomega[ 9]);
+
+ sCh6->SetVertex(4, xomega[12], yomega[12]);
+ sCh6->SetVertex(5, xomega[13], yomega[13]);
+ sCh6->SetVertex(6, xomega[14], yomega[14]);
+ sCh6->SetVertex(7, xomega[15], yomega[15]);
+
+ sCh7->SetVertex(4,-xomega[21], yomega[21]);
+ sCh7->SetVertex(5,-xomega[20], yomega[20]);
+ sCh7->SetVertex(6,-xomega[23], yomega[23]);
+ sCh7->SetVertex(7,-xomega[22], yomega[22]);
+
+ sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]);
+ sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]);
+ sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]);
+ sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]);
+
+ sCh9->SetVertex(4,-xomega[17], yomega[17]);
+ sCh9->SetVertex(5,-xomega[16], yomega[16]);
+ sCh9->SetVertex(6,-xomega[19], yomega[19]);
+ sCh9->SetVertex(7,-xomega[18], yomega[18]);
+
+ sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]);
+ sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]);
+ sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]);
+ sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]);
+
+ sCh11->SetVertex(4,-xomega[13], yomega[13]);
+ sCh11->SetVertex(5,-xomega[12], yomega[12]);
+ sCh11->SetVertex(6,-xomega[15], yomega[15]);
+ sCh11->SetVertex(7,-xomega[14], yomega[14]);
+
+ // Now the actual carbon fiber cone: a CompositeShape
+ TGeoCompositeShape *sCone = new TGeoCompositeShape("sCone",
+ "sC1+sC2+sC3+sC4+sC5+sC6+sC7+sC8+sC9+sC10+sC11");
+
+ // Finally the carbon fiber Ring with its Wings and their
+ // stesalite inserts. They are Tube and TubeSeg shapes
+
+ 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);
+ centralshield->SetFillColor(centralshield->GetLineColor());
+ centralshield->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
+ endcapshape,medSPDcf);
+ endcapshield->SetVisibility(kTRUE);
+ endcapshield->SetLineColor(7);
+ endcapshield->SetLineWidth(1);
+ endcapshield->SetFillColor(endcapshield->GetLineColor());
+ endcapshield->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillerblock = new TGeoVolume("SPDfillerblock",
+ fillershape,medSPDcf);
+ fillerblock->SetVisibility(kTRUE);
+ fillerblock->SetLineColor(7);
+ fillerblock->SetLineWidth(1);
+ fillerblock->SetFillColor(fillerblock->GetLineColor());
+ fillerblock->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillerhole = new TGeoVolume("SPDfillerhole",
+ fillerholeshape,medSPDair);
+ fillerhole->SetVisibility(kTRUE);
+ fillerhole->SetLineColor(5); // Yellow
+ fillerhole->SetLineWidth(1);
+ fillerhole->SetFillColor(fillerhole->GetLineColor());
+ fillerhole->SetFillStyle(4090); // 90% transparent
+
+ ypos = (fillershape->GetY(0)+fillershape->GetY(1))/2;
+ fillerblock->AddNode(fillerhole, 1, new TGeoTranslation(0, ypos, 0));
+
+ zpos = omgendcapshape->GetZ(1) - fillershape->GetZ(1) - kFillerBlockZTrans;
+ endcapshield->AddNode(fillerblock, 1, new TGeoTranslation(0, 0, zpos));
+ endcapshield->AddNode(fillerblock, 2, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("", kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 3, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("",-kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 4, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("", 2*kThetaDeg,0,0)));
+ endcapshield->AddNode(fillerblock, 5, new TGeoCombiTrans(0, 0, zpos,
+ new TGeoRotation("",-2*kThetaDeg,0,0)));
+
+ TGeoVolume *fillerbar = new TGeoVolume("SPDfillerbar",
+ fillbarshape,medSPDcf);
+ fillerbar->SetVisibility(kTRUE);
+ fillerbar->SetLineColor(7);
+ fillerbar->SetLineWidth(1);
+ fillerbar->SetFillColor(fillerbar->GetLineColor());
+ fillerbar->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *fillbarhole = new TGeoVolume("SPDfillerbarhole",
+ fillbarholeshape,medSPDair);
+ fillbarhole->SetVisibility(kTRUE);
+ fillbarhole->SetLineColor(5); // Yellow
+ fillbarhole->SetLineWidth(1);
+ fillbarhole->SetFillColor(fillbarhole->GetLineColor());
+ fillbarhole->SetFillStyle(4090); // 90% transparent
+
+ fillerbar->AddNode(fillbarhole, 1, 0);
+
+ TGeoVolume *vCone = new TGeoVolume("SPDconeshield",sCone,medSPDcf);
+ vCone->SetVisibility(kTRUE);
+ vCone->SetLineColor(7);
+ vCone->SetLineWidth(1);
+ vCone->SetFillColor(vCone->GetLineColor());
+ vCone->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
+ vCh1->SetVisibility(kTRUE);
+ vCh1->SetLineColor(5); // Yellow
+ vCh1->SetLineWidth(1);
+ vCh1->SetFillColor(vCh1->GetLineColor());
+ vCh1->SetFillStyle(4090); // 90% transparent
+
+ 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
+
+ TGeoVolume *vCh3 = new TGeoVolume("SPDconeshieldH3",sCh3,medSPDair);
+ vCh3->SetVisibility(kTRUE);
+ vCh3->SetLineColor(5); // Yellow
+ vCh3->SetLineWidth(1);
+ vCh3->SetFillColor(vCh3->GetLineColor());
+ vCh3->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh4 = new TGeoVolume("SPDconeshieldH4",sCh4,medSPDair);
+ vCh4->SetVisibility(kTRUE);
+ vCh4->SetLineColor(5); // Yellow
+ vCh4->SetLineWidth(1);
+ vCh4->SetFillColor(vCh4->GetLineColor());
+ vCh4->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh5 = new TGeoVolume("SPDconeshieldH5",sCh5,medSPDair);
+ vCh5->SetVisibility(kTRUE);
+ vCh5->SetLineColor(5); // Yellow
+ vCh5->SetLineWidth(1);
+ vCh5->SetFillColor(vCh5->GetLineColor());
+ vCh5->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh6 = new TGeoVolume("SPDconeshieldH6",sCh6,medSPDair);
+ vCh6->SetVisibility(kTRUE);
+ vCh6->SetLineColor(5); // Yellow
+ vCh6->SetLineWidth(1);
+ vCh6->SetFillColor(vCh6->GetLineColor());
+ vCh6->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh7 = new TGeoVolume("SPDconeshieldH7",sCh7,medSPDair);
+ vCh7->SetVisibility(kTRUE);
+ vCh7->SetLineColor(5); // Yellow
+ vCh7->SetLineWidth(1);
+ vCh7->SetFillColor(vCh7->GetLineColor());
+ vCh7->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh8 = new TGeoVolume("SPDconeshieldH8",sCh8,medSPDair);
+ vCh8->SetVisibility(kTRUE);
+ vCh8->SetLineColor(5); // Yellow
+ vCh8->SetLineWidth(1);
+ vCh8->SetFillColor(vCh8->GetLineColor());
+ vCh8->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh9 = new TGeoVolume("SPDconeshieldH9",sCh9,medSPDair);
+ vCh9->SetVisibility(kTRUE);
+ vCh9->SetLineColor(5); // Yellow
+ vCh9->SetLineWidth(1);
+ vCh9->SetFillColor(vCh9->GetLineColor());
+ vCh9->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh10 = new TGeoVolume("SPDconeshieldH10",sCh10,medSPDair);
+ vCh10->SetVisibility(kTRUE);
+ vCh10->SetLineColor(5); // Yellow
+ vCh10->SetLineWidth(1);
+ vCh10->SetFillColor(vCh10->GetLineColor());
+ vCh10->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *vCh11 = new TGeoVolume("SPDconeshieldH11",sCh11,medSPDair);
+ vCh11->SetVisibility(kTRUE);
+ vCh11->SetLineColor(5); // Yellow
+ vCh11->SetLineWidth(1);
+ vCh11->SetFillColor(vCh11->GetLineColor());
+ vCh11->SetFillStyle(4090); // 90% transparent
+
+ vCone->AddNode(vCh1 ,1,0);
+ vCone->AddNode(vCh2 ,1,0);
+ vCone->AddNode(vCh3 ,1,0);
+ vCone->AddNode(vCh4 ,1,0);
+ vCone->AddNode(vCh5 ,1,0);
+ vCone->AddNode(vCh6 ,1,0);
+ vCone->AddNode(vCh7 ,1,0);
+ vCone->AddNode(vCh8 ,1,0);
+ vCone->AddNode(vCh9 ,1,0);
+ vCone->AddNode(vCh10,1,0);
+ vCone->AddNode(vCh11,1,0);
+
+ TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
+ ring->SetVisibility(kTRUE);
+ 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("SPDshieldwinginsert",
+ 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
+ const Double_t kLittleZTrans = 0.1*fgkmm;
+ vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans));
+ vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans,
+ new TGeoRotation("",180,0,0)));
+
+ zpos = kHalfLengthCentral+kHalfLengthEndCap;
+ vM->AddNode(endcapshield,1,
+ new TGeoTranslation(0,0, zpos-kLittleZTrans));
+ vM->AddNode(endcapshield,2,new TGeoCombiTrans(
+ 0, 0,-zpos-kLittleZTrans, new TGeoRotation("", 0,180,0) ) );
+ vM->AddNode(endcapshield,3,new TGeoCombiTrans(
+ 0, 0, zpos-kLittleZTrans, new TGeoRotation("",180, 0,0) ) );
+ vM->AddNode(endcapshield,4,new TGeoCombiTrans(
+ 0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,180,0) ) );
+
+ xpos = omgendcapshape->GetX(13) + fillbarshape->GetDX();
+ ypos = omgendcapshape->GetY(13) + fillbarshape->GetDY();
+ zpos -= fillbarshape->GetDZ();
+ vM->AddNode(fillerbar, 1, new TGeoTranslation( xpos, ypos, zpos));
+ vM->AddNode(fillerbar, 2, new TGeoTranslation(-xpos, ypos, zpos));
+ vM->AddNode(fillerbar, 3, new TGeoTranslation( xpos,-ypos, zpos));
+ vM->AddNode(fillerbar, 4, new TGeoTranslation(-xpos,-ypos, zpos));
+ vM->AddNode(fillerbar, 5, new TGeoTranslation( xpos, ypos,-zpos));
+ vM->AddNode(fillerbar, 6, new TGeoTranslation(-xpos, ypos,-zpos));
+ vM->AddNode(fillerbar, 7, new TGeoTranslation( xpos,-ypos,-zpos));
+ vM->AddNode(fillerbar, 8, new TGeoTranslation(-xpos,-ypos,-zpos));
+
+ zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone;
+ vM->AddNode(vCone ,1, new TGeoTranslation(0, 0, zpos-kLittleZTrans));
+
+ vM->AddNode(vCone ,2, new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 0, 180) ));
+
+ vM->AddNode(vCone ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 180, 0) ));
+
+ vM->AddNode(vCone ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
+ new TGeoRotation("", 0, 180, 180) ));
+
+ zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
+ + kHalfLengthRing;
+ vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
+ vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));
+
+ for (Int_t i=0; i<4; i++) {
+ Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
+ vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
+ vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
+ new TGeoRotation("",thetaW,0,0) ) );
+ }
+
+ // Some debugging if requested
+ 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 ) const
+{
+//
+// 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::SPDThermalSheald(TGeoVolume *Moth){
- // Define the detail SPD Thermal Sheld geometry.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- // From ALICE-Thermal Screen (SPD) "Cylinder" file thermal-screen2_a3.ps
- // Volumes A1,A2,A2,Ah1,Ah2,Ah3, and B1,B2,B3,Bh1,Bh2,Bh3;
- // "CONE TRANSITION" file thermal-screen1_a3.ps Volumes C1,C2,C3,Ch1,Ch2,
- // Ch3; "FLANGE" file thermal-screen4_a3.ps Volumes D,Ds,Dw,Dws; 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 M1 and 4 copies of M2.
- const Double_t TSCarbonFiberThA = 0.03*kmm; //
- //const Double_t TSCarbonFiberThB = 0.10*kmm; //
- const Double_t TSCLengthB = 50.0*kmm; //
- const Double_t TSCLengthA = 900.0*kmm-2.0*TSCLengthB; //
- const Double_t TSCLengthC = 290.0*kmm; //
- const Double_t TSCLengthD = 15.0*kmm; //
- const Double_t TSCAngle = 36.0*kDegree;//Rep. angle of cent. accordin
- const Double_t TSCRoutA = 99.255*kmm; // Outer radii
- const Double_t TSCRinA = 81.475*kmm; // Iner radii
- const Double_t TSCRoutB = 99.955*kmm; // Outer radii
- const Double_t TSCRinB = 80.775*kmm; // Iner radii
- const Double_t TSCRoutCp = 390.0*kmm; // Outer radii
- const Double_t TSCRinCp = 373.0*kmm; // Iner radii
- Double_t TSCRoutC,TSCRinC; // values need to be calculated
- const Double_t TSCRwingD = 492.5*kmm; // Outer radii
- const Double_t TSCRoutD = 0.5*840.*kmm;// Outer radii
- const Double_t TSCRinD = 373.0*kmm; // Iner radii
- const Double_t TSCAngleDD = 60.*kmm/TSCRwingD/kRadian;// angular wing
- // width of fill material
- const Double_t TSCAngleDDs = (60.*kmm-2.*TSCarbonFiberThA)/
- TSCRwingD/kRadian;
- const Double_t TSCAngleD0 = 45.*kDegree;//Strting angle of wing
- const Double_t TSCoutSA = 24.372*kmm; // The other one Calculated
- const Double_t TSCinLA = 31.674*kmm; // The ohter one Calculated
- const Double_t TSCoutSB = 24.596*kmm; // The other one Calculated
- const Double_t TSCinLB = 31.453*kmm; // The ohter one Calculated
- const Double_t TSCoutSC = 148.831*kmm;// The other one Calculated
- const Double_t TSCinLC = 90.915*kmm; // 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 *A1,*A2,*A3,*Ah1,*Ah2,*Ah3,*B1,*B2,*B3,*Bh1,*Bh2,*Bh3;
- TGeoArb8 *C1,*C2,*C3,*Ch1,*Ch2,*Ch3;
- TGeoTube *D,*Ds;
- TGeoTubeSeg *Dw,*Dws;
- TGeoCompositeShape *M;
- TGeoRotation *rot;
- TGeoTranslation *tranb,*tranbm,*tranc;
- TGeoTranslation *tranITSspdShealdVVt0;
- TGeoCombiTrans *rotITSspdShealdVVt1,*rotITSspdShealdVVt2;
- TGeoCombiTrans *rotITSspdShealdVVt3;
- TGeoMedium *SPDcf = 0; // SPD support cone Carbon Fiber materal number.
- TGeoMedium *SPDfs = 0; // SPD support cone inserto stesalite 4411w.
- TGeoMedium *SPDfo = 0; // SPD support cone foam, Rohacell 50A.
- TGeoMedium *SPDss = 0; // SPD support cone screw material,Stainless steal
- TGeoMedium *SPDair = 0; // SPD support cone Air
- //TGeoMedium *SPDal = 0; // SPD support cone SDD mounting bracket Al
-
- TSCRoutC = TMath::Sqrt(TSCRoutCp*TSCRoutCp-0.25*TSCoutSC*TSCoutSC);
- TSCRinC = TMath::Sqrt(TSCRinCp *TSCRinCp -0.25*TSCinLC *TSCinLC );
- A1 = new TGeoArb8("ITS SPD Therm Screen Clyinder A1",0.5*TSCLengthA);
- A2 = new TGeoArb8("ITS SPD Therm Screen Clyinder A2",0.5*TSCLengthA);
- A3 = new TGeoArb8("ITS SPD Therm Screen Clyinder A3",0.5*TSCLengthA);
- Ah1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah1",0.5*TSCLengthA);
- Ah2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah2",0.5*TSCLengthA);
- Ah3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ah3",0.5*TSCLengthA);
- B1 = new TGeoArb8("ITS SPD Therm Screen Clyinder B1",0.5*TSCLengthB);
- B2 = new TGeoArb8("ITS SPD Therm Screen Clyinder B2",0.5*TSCLengthB);
- B3 = new TGeoArb8("ITS SPD Therm Screen Clyinder B3",0.5*TSCLengthB);
- Bh1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh1",0.5*TSCLengthB);
- Bh2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh2",0.5*TSCLengthB);
- Bh3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Bh3",0.5*TSCLengthB);
- C1 = new TGeoArb8("ITS SPD Therm Screen Clyinder C1",0.5*TSCLengthC);
- C2 = new TGeoArb8("ITS SPD Therm Screen Clyinder C2",0.5*TSCLengthC);
- C3 = new TGeoArb8("ITS SPD Therm Screen Clyinder C3",0.5*TSCLengthC);
- Ch1 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch1",0.5*TSCLengthC);
- Ch2 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch2",0.5*TSCLengthC);
- Ch3 = new TGeoArb8("ITS SPD Therm Screen Cylinder Ch3",0.5*TSCLengthC);
- D = new TGeoTube("ITS SPD Therm Screen Flange D",TSCRinD,TSCRoutD,
- 0.5*TSCLengthD);
- Ds = new TGeoTube("ITS SPD Therm Screen Flange fill Ds",
- TSCRinD+TSCarbonFiberThA,TSCRoutD-TSCarbonFiberThA,
- 0.5*TSCLengthD);
- printTube(D);
- printTube(Ds);
- Dw = new TGeoTubeSeg("ITS SPD Therm Screen Flange Wing Dw",
- TSCRoutD,TSCRwingD ,0.5*TSCLengthD,
- TSCAngleD0-0.5*TSCAngleDD,TSCAngleD0+0.5*TSCAngleDD);
- Dws = new TGeoTubeSeg("ITS SPD Therm Screen Flange Wing Fill Ds",
- TSCRoutD,TSCRwingD-TSCarbonFiberThA,
- 0.5*TSCLengthD,TSCAngleD0-0.5*TSCAngleDDs,
- TSCAngleD0+0.5*TSCAngleDDs);
- printTubeSeg(Dw);
- printTubeSeg(Dws);
- k = 0;
- for(i=-1;i<2;i++){
- th = ((Double_t)(i+1))*TSCAngle*kRadian;
- xo[k] = TSCRoutA*TMath::Sin(th) - 0.5*TSCoutSA*TMath::Cos(th);
- yo[k] = TSCRoutA*TMath::Cos(th) + 0.5*TSCoutSA*TMath::Sin(th);
- xi[k] = TSCRinA *TMath::Sin(th) - 0.5*TSCinLA *TMath::Cos(th);
- yi[k] = TSCRinA *TMath::Cos(th) + 0.5*TSCinLA *TMath::Sin(th);
- xbo[k] = TSCRoutB*TMath::Sin(th) - 0.5*TSCoutSB*TMath::Cos(th);
- ybo[k] = TSCRoutB*TMath::Cos(th) + 0.5*TSCoutSB*TMath::Sin(th);
- xbi[k] = TSCRinB *TMath::Sin(th) - 0.5*TSCinLB *TMath::Cos(th);
- ybi[k] = TSCRinB *TMath::Cos(th) + 0.5*TSCinLB *TMath::Sin(th);
- xco[k] = TSCRoutC*TMath::Sin(th) - 0.5*TSCoutSC*TMath::Cos(th);
- yco[k] = TSCRoutC*TMath::Cos(th) + 0.5*TSCoutSC*TMath::Sin(th);
- xci[k] = TSCRinC *TMath::Sin(th) - 0.5*TSCinLC *TMath::Cos(th);
- yci[k] = TSCRinC *TMath::Cos(th) + 0.5*TSCinLC *TMath::Sin(th);
- k++;
- xo[k] = TSCRoutA*TMath::Sin(th) + 0.5*TSCoutSA*TMath::Cos(th);
- yo[k] = TSCRoutA*TMath::Cos(th) - 0.5*TSCoutSA*TMath::Sin(th);
- xi[k] = TSCRinA *TMath::Sin(th) + 0.5*TSCinLA *TMath::Cos(th);
- yi[k] = TSCRinA *TMath::Cos(th) - 0.5*TSCinLA *TMath::Sin(th);
- xbo[k] = TSCRoutB*TMath::Sin(th) + 0.5*TSCoutSB*TMath::Cos(th);
- ybo[k] = TSCRoutB*TMath::Cos(th) - 0.5*TSCoutSB*TMath::Sin(th);
- xbi[k] = TSCRinB *TMath::Sin(th) + 0.5*TSCinLB *TMath::Cos(th);
- ybi[k] = TSCRinB *TMath::Cos(th) - 0.5*TSCinLB *TMath::Sin(th);
- xco[k] = TSCRoutC*TMath::Sin(th) + 0.5*TSCoutSC*TMath::Cos(th);
- yco[k] = TSCRoutC*TMath::Cos(th) - 0.5*TSCoutSC*TMath::Sin(th);
- xci[k] = TSCRinC *TMath::Sin(th) + 0.5*TSCinLC *TMath::Cos(th);
- yci[k] = TSCRinC *TMath::Cos(th) - 0.5*TSCinLC *TMath::Sin(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(GetDebug()){
- cout.precision(4);
- cout.width(7);
- cout <<"i \t xo yo \t xi yi \t xbo ybo \t xbi ybi "
- "\t xco yco \t xci yxi"<<endl;
- for(i=0;i<7;i++){
- cout << i <<"\t"<<xo[i]<<","<<yo[i];
- cout <<"\t"<<xi[i]<<","<<yi[i];
- cout <<"\t"<<xbo[i]<<","<<ybo[i];
- cout <<"\t"<<xbi[i]<<","<<ybi[i];
- cout <<"\t"<<xco[i]<<","<<yco[i];
- cout <<"\t"<<xci[i]<<","<<yci[i];
- cout<<endl;}
- } // end if GetDebug()
- //+++++++++++++++++++++++++
- A1->SetVertex(0,xo[0],yo[0]);
- A1->SetVertex(1,xo[1],yo[1]);
- A1->SetVertex(2,xi[1],yi[1]);
- A1->SetVertex(3,xi[0],yi[0]);
- //
- A2->SetVertex(0,xo[1],yo[1]);
- A2->SetVertex(1,xo[2],yo[2]);
- A2->SetVertex(2,xi[2],yi[2]);
- A2->SetVertex(3,xi[1],yi[1]);
- //
- A3->SetVertex(0,xo[5],yo[5]);
- A3->SetVertex(1,xo[6],yo[6]);
- A3->SetVertex(2,xi[6],yi[6]);
- A3->SetVertex(3,xi[5],yi[5]);
- //--------------------------
- B1->SetVertex(0,xbo[0],ybo[0]);
- B1->SetVertex(1,xbo[1],ybo[1]);
- B1->SetVertex(2,xbi[1],ybi[1]);
- B1->SetVertex(3,xbi[0],ybi[0]);
- //
- B2->SetVertex(0,xbo[1],ybo[1]);
- B2->SetVertex(1,xbo[2],ybo[2]);
- B2->SetVertex(2,xbi[2],ybi[2]);
- B2->SetVertex(3,xbi[1],ybi[1]);
- //
- B3->SetVertex(0,xbo[5],ybo[5]);
- B3->SetVertex(1,xbo[6],ybo[6]);
- B3->SetVertex(2,xbi[6],ybi[6]);
- B3->SetVertex(3,xbi[5],ybi[5]);
- //--------------------------
- C1->SetVertex(0,xco[0],yco[0]);
- C1->SetVertex(1,xco[1],yco[1]);
- C1->SetVertex(2,xci[1],yci[1]);
- C1->SetVertex(3,xci[0],yci[0]);
- //
- C2->SetVertex(0,xco[1],yco[1]);
- C2->SetVertex(1,xco[2],yco[2]);
- C2->SetVertex(2,xci[2],yci[2]);
- C2->SetVertex(3,xci[1],yci[1]);
- //
- C3->SetVertex(0,xco[5],yco[5]);
- C3->SetVertex(1,xco[6],yco[6]);
- C3->SetVertex(2,xci[6],yci[6]);
- C3->SetVertex(3,xci[5],yci[5]);
- // Defining the hole, filled with air
- Double_t p1,c1,x,y,x7[3],y7[3];
- p1 = (xo[0]-xi[0])/(yo[0]-yi[0]);
- c1 = xo[0]+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xo[0]-xi[0])+
- SQ(yo[0]-yi[0]))/(xo[0]-xi[0]);
- y = TSCRoutA-2.*TSCarbonFiberThA;
- x = p1*(y-yo[0])+c1;
- Ah1->SetVertex(0,x,y);
- Bh1->SetVertex(0,x,y);
- Ch1->SetVertex(4,x,y);
- y = TSCRinA+TSCarbonFiberThA;
- x = p1*(y-yo[0])+c1;
- Ah1->SetVertex(3,x,y);
- Bh1->SetVertex(3,x,y);
- x7[0] = x; y7[0] = y; // vortexing done after last point
- //Ch1->SetVertex(7,x,y);
- p1 = (xo[1]-xi[1])/(yo[1]-yi[1]);
- c1 = xo[1]-0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xo[1]-xi[1])+
- SQ(yo[1]-yi[1]))/(xo[1]-xi[1]);
- y = TSCRoutA-2.*TSCarbonFiberThA;
- x = p1*(y-yo[1])+c1;
- Ah1->SetVertex(1,x,y);
- Bh1->SetVertex(1,x,y);
- Ch1->SetVertex(5,x,y);
- y = TSCRinA+TSCarbonFiberThA;
- x = p1*(y-yo[1])+c1;
- Ah1->SetVertex(2,x,y);
- Bh1->SetVertex(2,x,y);
- Ch1->SetVertex(6,x,y);
- //
- // The easist way to get the points for the hole in volume A2 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*TSCAngle*kRadian;
- xa = TMath::Cos(th)*xo[1]-TMath::Sin(th)*yo[1];
- ya = TMath::Sin(th)*xo[1]+TMath::Cos(th)*yo[1];
- xb = TMath::Cos(th)*xi[1]-TMath::Sin(th)*yi[1];
- yb = TMath::Sin(th)*xi[1]+TMath::Cos(th)*yi[1];
- p1 = (xa-xb)/(ya-yb);
- c1 = xa+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb);
- y = ya-TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ah2->SetVertex(0,xp,yp);
- Bh2->SetVertex(0,xp,yp);
- Ch2->SetVertex(4,xp,yp);
- y = yb+2.0*TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ah2->SetVertex(3,xp,yp);
- Bh2->SetVertex(3,xp,yp);
- x7[1] = x; y7[1] = y; // vortexing done after last point
- //Ch2->SetVertex(7,xp,yp);
- xa = TMath::Cos(th)*xo[2]-TMath::Sin(th)*yo[2];
- ya = TMath::Sin(th)*xo[2]+TMath::Cos(th)*yo[2];
- xb = TMath::Cos(th)*xi[2]-TMath::Sin(th)*yi[2];
- yb = TMath::Sin(th)*xi[2]+TMath::Cos(th)*yi[2];
- p1 = (xa-xb)/(ya-yb);
- c1 = xa-0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb);
- y = ya-TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ah2->SetVertex(1,xp,yp);
- Bh2->SetVertex(1,xp,yp);
- Ch2->SetVertex(5,xp,yp);
- y = yb+2.0*TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ah2->SetVertex(2,xp,yp);
- Bh2->SetVertex(2,xp,yp);
- Ch2->SetVertex(6,xp,yp);
- //
- p1 = (yo[5]-yi[5])/(xo[5]-xi[5]);
- c1 = yo[5]+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(yo[5]-yi[5])+
- SQ(xo[5]-xi[5]))/(yo[5]-yi[5]);
- x = xo[5]-TSCarbonFiberThA;
- y = p1*(x-xo[5])+c1;
- Ah3->SetVertex(0,x,y);
- Bh3->SetVertex(0,x,y);
- Ch3->SetVertex(4,x,y);
- x = xi[5]+2.0*TSCarbonFiberThA;
- y = p1*(x-xo[5])+c1;
- Ah3->SetVertex(3,x,y);
- Bh3->SetVertex(3,x,y);
- x7[2] = x; y7[2] = y; // vortexing done after last point
- //Ch3->SetVertex(7,x,y);
- y = 2.0*TSCarbonFiberThA;
- x = xo[5]-TSCarbonFiberThA;
- Ah3->SetVertex(1,x,y);
- Bh3->SetVertex(1,x,y);
- Ch3->SetVertex(5,x,y);
- y = 2.0*TSCarbonFiberThA;
- x = xi[5]+2.0*TSCarbonFiberThA;
- Ah3->SetVertex(2,x,y);
- Bh3->SetVertex(2,x,y);
- Ch3->SetVertex(6,x,y);
- //
- for(i=0;i<4;i++){ // define points at +dz
- A1->SetVertex(i+4,(A1->GetVertices())[2*i],(A1->GetVertices())[1+2*i]);
- A2->SetVertex(i+4,(A2->GetVertices())[2*i],(A2->GetVertices())[1+2*i]);
- A3->SetVertex(i+4,(A3->GetVertices())[2*i],(A3->GetVertices())[1+2*i]);
- //
- B1->SetVertex(i+4,(B1->GetVertices())[2*i],(B1->GetVertices())[1+2*i]);
- B2->SetVertex(i+4,(B2->GetVertices())[2*i],(B2->GetVertices())[1+2*i]);
- B3->SetVertex(i+4,(B3->GetVertices())[2*i],(B3->GetVertices())[1+2*i]);
- // C's are a cone which must match up with B's.
- C1->SetVertex(i+4,(B1->GetVertices())[2*i],(B1->GetVertices())[1+2*i]);
- C2->SetVertex(i+4,(B2->GetVertices())[2*i],(B2->GetVertices())[1+2*i]);
- C3->SetVertex(i+4,(B3->GetVertices())[2*i],(B3->GetVertices())[1+2*i]);
- //
- Ah1->SetVertex(i+4,(Ah1->GetVertices())[2*i],
- (Ah1->GetVertices())[1+2*i]);
- Ah2->SetVertex(i+4,(Ah2->GetVertices())[2*i],
- (Ah2->GetVertices())[1+2*i]);
- Ah3->SetVertex(i+4,(Ah3->GetVertices())[2*i],
- (Ah3->GetVertices())[1+2*i]);
- //
- Bh1->SetVertex(i+4,(Bh1->GetVertices())[2*i],
- (Bh1->GetVertices())[1+2*i]);
- Bh2->SetVertex(i+4,(Bh2->GetVertices())[2*i],
- (Bh2->GetVertices())[1+2*i]);
- Bh3->SetVertex(i+4,(Bh3->GetVertices())[2*i],
- (Bh3->GetVertices())[1+2*i]);
- } // end for
- //
- p1 = (xco[0]-xci[0])/(yco[0]-yci[0]);
- c1 = xco[0]+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xco[0]-xci[0])+
- SQ(yco[0]-yci[0]))/(xco[0]-xci[0]);
- y = TSCRoutC-2.*TSCarbonFiberThA;
- x = p1*(y-yco[0])+c1;
- Ch1->SetVertex(0,x,y);
- y = TSCRinC+TSCarbonFiberThA;
- x = p1*(y-yci[0])+c1;
- Ch1->SetVertex(2,x,y);
- p1 = (xco[1]-xci[1])/(yco[1]-yci[1]);
- c1 = xco[1]-0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xco[1]-xci[1])+
- SQ(yco[1]-yci[1]))/(xco[1]-xci[1]);
- y = TSCRoutC-2.*TSCarbonFiberThA;
- x = p1*(y-yco[1])+c1;
- Ch1->SetVertex(1,x,y);
- y = TSCRinC+TSCarbonFiberThA;
- x = p1*(y-yci[1])+c1;
- Ch1->SetVertex(3,x,y);
- //
- th = 0.5*TSCAngle*kRadian;
- xa = TMath::Cos(th)*xco[1]-TMath::Sin(th)*yco[1];
- ya = TMath::Sin(th)*xco[1]+TMath::Cos(th)*yco[1];
- xb = TMath::Cos(th)*xci[1]-TMath::Sin(th)*yci[1];
- yb = TMath::Sin(th)*xci[1]+TMath::Cos(th)*yci[1];
- p1 = (xa-xb)/(ya-yb);
- c1 = xa+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb);
- y = ya-TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- yp = ya-TSCarbonFiberThA;
- xp = p1*(y-ya)+c1;
- Ch2->SetVertex(0,xp,yp);
- y = yb+2.0*TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ch2->SetVertex(2,xp,yp);
- xa = TMath::Cos(th)*xco[2]-TMath::Sin(th)*yco[2];
- ya = TMath::Sin(th)*xco[2]+TMath::Cos(th)*yco[2];
- xb = TMath::Cos(th)*xci[2]-TMath::Sin(th)*yci[2];
- yb = TMath::Sin(th)*xci[2]+TMath::Cos(th)*yci[2];
- p1 = (xa-xb)/(ya-yb);
- c1 = xa-0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(xa-xb)+SQ(ya-yb))/(xa-xb);
- y = ya-TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ch2->SetVertex(1,xp,yp);
- y = yb+2.0*TSCarbonFiberThA;
- x = p1*(y-ya)+c1;
- xp = TMath::Cos(-th)*x-TMath::Sin(-th)*y;
- yp = TMath::Sin(-th)*x+TMath::Cos(-th)*y;
- Ch2->SetVertex(3,xp,yp);
- //
- p1 = (yco[5]-yci[5])/(xco[5]-xci[5]);
- c1 = yco[5]+0.5*TSCarbonFiberThA*TMath::Sqrt(SQ(yco[5]-yci[5])+
- SQ(xco[5]-xci[5]))/(yco[5]-yci[5]);
- x = xco[5]-TSCarbonFiberThA;
- y = p1*(x-xco[5])+c1;
- Ch3->SetVertex(0,x,y);
- x = xci[5]+2.0*TSCarbonFiberThA;
- y = p1*(x-xci[5])+c1;
- Ch3->SetVertex(2,x,y);
- y = 2.0*TSCarbonFiberThA;
- x = xco[5]-TSCarbonFiberThA;
- Ch3->SetVertex(1,x,y);
- y = 2.0*TSCarbonFiberThA;
- x = xci[5]+2.0*TSCarbonFiberThA;
- Ch3->SetVertex(3,x,y);
- Ch1->SetVertex(7,x7[0],y7[0]); // 7th point most be done last ???
- Ch2->SetVertex(7,x7[1],y7[1]); // 7th point most be done last ???
- Ch3->SetVertex(7,x7[2],y7[2]); // 7th point most be done last ???
- printArb8(A1);
- printArb8(Ah1);
- printArb8(A2);
- printArb8(Ah2);
- printArb8(A3);
- printArb8(Ah3);
- printArb8(B1);
- printArb8(Bh1);
- printArb8(B2);
- printArb8(Bh2);
- printArb8(B3);
- printArb8(Bh3);
- printArb8(C1);
- printArb8(Ch1);
- printArb8(C2);
- printArb8(Ch2);
- printArb8(C3);
- printArb8(Ch3);
- //
- // Define Minimal volume to inclose this SPD Thermal Sheald.
- TGeoPcon *M1 = new TGeoPcon("ITSspdShealdVV",0.0,360.0,9);
- M1->Z(0) = 0.5*TSCLengthA+TSCLengthB;
- M1->Rmin(0) = TSCRinB;
- x = B1->GetVertices()[0]; // [0][0]
- y = B1->GetVertices()[1]; // [0][1]
- M1->Rmax(0) = TMath::Sqrt(x*x+y*y);
- M1->Z(1) = M1->GetZ(0)-TSCLengthB;
- M1->Rmin(1) = M1->GetRmin(0);
- M1->Rmax(1) = M1->GetRmax(0);
- M1->Z(2) = M1->GetZ(1);
- M1->Rmin(2) = TSCRinA;
- x = A1->GetVertices()[0]; // [0]0]
- y = A1->GetVertices()[1]; // [0][1]
- M1->Rmax(2) = TMath::Sqrt(x*x+y*y);
- M1->Z(3) = -(M1->GetZ(0)-TSCLengthB);
- M1->Rmin(3) = M1->GetRmin(2);
- M1->Rmax(3) = M1->GetRmax(2);
- M1->Z(4) = M1->GetZ(3);
- M1->Rmin(4) = M1->GetRmin(1);
- M1->Rmax(4) = M1->GetRmax(1);
- M1->Z(5) = -(M1->GetZ(0));
- M1->Rmin(5) = M1->GetRmin(0);
- M1->Rmax(5) = M1->GetRmax(0);
- M1->Z(6) = M1->GetZ(5) - TSCLengthC;
- M1->Rmin(6) = TSCRinC;
- x = C1->GetVertices()[0]; // [0][0]
- y = C1->GetVertices()[1]; // [0][1]
- M1->Rmax(6) = TMath::Sqrt(x*x+y*y);
- M1->Z(7) = M1->GetZ(6);
- M1->Rmin(7) = D->GetRmin();
- M1->Rmax(7) = D->GetRmax();
- M1->Z(8) = M1->Z(7) - TSCLengthD;
- M1->Rmin(8) = M1->GetRmin(7);
- M1->Rmax(8) = M1->GetRmax(7);
- TGeoTubeSeg *M2 = new TGeoTubeSeg("ITSspdShealdWingVV",
- M1->GetRmax(8),Dw->GetRmax(),Dw->GetDz(),Dw->GetPhi1(),Dw->GetPhi2());
- printTubeSeg(M2);
- //
- x = 0.5*(M1->GetZ(8) + M1->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();
- M = new TGeoCompositeShape("ITS SPD Thermal sheald volume",
- "(((ITSspdShealdVV+"
- "ITSspdShealdWingVV:ITSspdShealdVVt0)+"
- "ITSspdShealdWingVV:ITSspdShealdVVt1)+"
- "ITSspdShealdWingVV:ITSspdShealdVVt2)+"
- "ITSspdShealdWingVV:ITSspdShealdVVt3");
- //
- TGeoManager *mgr = gGeoManager;
- SPDcf = mgr->GetMedium("ITSspdCarbonFiber");
- SPDfs = mgr->GetMedium("ITSspdStaselite4411w");
- SPDfo = mgr->GetMedium("ITSspdRohacell50A");
- SPDss = mgr->GetMedium("ITSspdStainlessSteal");
- SPDair= mgr->GetMedium("ITSspdAir");
- TGeoVolume *A1v,*A2v,*A3v,*Ah1v,*Ah2v,*Ah3v;
- TGeoVolume *B1v,*B2v,*B3v,*Bh1v,*Bh2v,*Bh3v;
- TGeoVolume *C1v,*C2v,*C3v,*Ch1v,*Ch2v,*Ch3v;
- TGeoVolume *Dv,*Dsv,*Dwv,*Dwsv,*Mv;
- Mv = new TGeoVolume("ITSspdThermalSheald",M,SPDair);
- Mv->SetVisibility(kTRUE);
- Mv->SetLineColor(7); // light Blue
- Mv->SetLineWidth(1);
- Mv->SetFillColor(Mv->GetLineColor());
- Mv->SetFillStyle(4090); // 90% transparent
- Moth->AddNode(Mv,1,0); ///////////////////// Virtual Volume ////////
- A1v = new TGeoVolume("ITSspdCentCylA1CF",A1,SPDcf);
- A1v->SetVisibility(kTRUE);
- A1v->SetLineColor(4);
- A1v->SetLineWidth(1);
- A2v = new TGeoVolume("ITSspdCentCylA2CF",A2,SPDcf);
- A2v->SetVisibility(kTRUE);
- A2v->SetLineColor(4);
- A2v->SetLineWidth(1);
- A3v = new TGeoVolume("ITSspdCentCylA3CF",A3,SPDcf);
- A3v->SetVisibility(kTRUE);
- A3v->SetLineColor(4);
- A3v->SetLineWidth(1);
- B1v = new TGeoVolume("ITSspdCentCylB1CF",B1,SPDcf);
- B1v->SetVisibility(kTRUE);
- B1v->SetLineColor(4);
- B1v->SetLineWidth(1);
- B2v = new TGeoVolume("ITSspdCentCylB2CF",B2,SPDcf);
- B2v->SetVisibility(kTRUE);
- B2v->SetLineColor(4);
- B2v->SetLineWidth(1);
- B3v = new TGeoVolume("ITSspdCentCylB3CF",B3,SPDcf);
- B3v->SetVisibility(kTRUE);
- B3v->SetLineColor(4);
- B3v->SetLineWidth(1);
- C1v = new TGeoVolume("ITSspdCentCylC1CF",C1,SPDcf);
- C1v->SetVisibility(kTRUE);
- C1v->SetLineColor(4);
- C1v->SetLineWidth(1);
- C2v = new TGeoVolume("ITSspdCentCylC2CF",C2,SPDcf);
- C2v->SetVisibility(kTRUE);
- C2v->SetLineColor(4);
- C2v->SetLineWidth(1);
- C3v = new TGeoVolume("ITSspdCentCylC3CF",C3,SPDcf);
- C3v->SetVisibility(kTRUE);
- C3v->SetLineColor(4);
- C3v->SetLineWidth(1);
- Ah1v = new TGeoVolume("ITSspdCentCylA1AirA",Ah1,SPDair);
- Ah1v->SetVisibility(kTRUE);
- Ah1v->SetLineColor(5); // Yellow
- Ah1v->SetFillColor(Ah1v->GetLineColor());
- Ah1v->SetFillStyle(4090); // 90% transparent
- Ah2v = new TGeoVolume("ITSspdCentCylA2AirA",Ah2,SPDair);
- Ah2v->SetVisibility(kTRUE);
- Ah2v->SetLineColor(5); // Yellow
- Ah2v->SetFillColor(Ah2v->GetLineColor());
- Ah2v->SetFillStyle(4090); // 90% transparent
- Ah3v = new TGeoVolume("ITSspdCentCylA3AirA",Ah3,SPDair);
- Ah3v->SetVisibility(kTRUE);
- Ah3v->SetLineColor(5); // Yellow
- Ah3v->SetFillColor(Ah3v->GetLineColor());
- Ah3v->SetFillStyle(4090); // 90% transparent
- Bh1v = new TGeoVolume("ITSspdCentCylA1AirB",Bh1,SPDair);
- Bh1v->SetVisibility(kTRUE);
- Bh1v->SetLineColor(5); // Yellow
- Bh1v->SetFillColor(Bh1v->GetLineColor());
- Bh1v->SetFillStyle(4090); // 90% transparent
- Bh2v = new TGeoVolume("ITSspdCentCylA2AirB",Bh2,SPDair);
- Bh2v->SetVisibility(kTRUE);
- Bh2v->SetLineColor(5); // Yellow
- Bh2v->SetFillColor(Bh2v->GetLineColor());
- Bh2v->SetFillStyle(4090); // 90% transparent
- Bh3v = new TGeoVolume("ITSspdCentCylA3AirB",Bh3,SPDair);
- Bh3v->SetVisibility(kTRUE);
- Bh3v->SetLineColor(5); // Yellow
- Bh3v->SetFillColor(Bh3v->GetLineColor());
- Bh3v->SetFillStyle(4090); // 90% transparent
- Ch1v = new TGeoVolume("ITSspdCentCylA1AirC",Ch1,SPDair);
- Ch1v->SetVisibility(kTRUE);
- Ch1v->SetLineColor(5); // Yellow
- Ch1v->SetFillColor(Ch1v->GetLineColor());
- Ch1v->SetFillStyle(4090); // 90% transparent
- Ch2v = new TGeoVolume("ITSspdCentCylA2AirC",Ch2,SPDair);
- Ch2v->SetVisibility(kTRUE);
- Ch2v->SetLineColor(5); // Yellow
- Ch2v->SetFillColor(Ch2v->GetLineColor());
- Ch2v->SetFillStyle(4090); // 90% transparent
- Ch3v = new TGeoVolume("ITSspdCentCylA3AirC",Ch3,SPDair);
- Ch3v->SetVisibility(kTRUE);
- Ch3v->SetLineColor(5); // Yellow
- Ch3v->SetFillColor(Ch3v->GetLineColor());
- Ch3v->SetFillStyle(4090); // 90% transparent
- Dv = new TGeoVolume("ITSspdCentCylA1CD",D,SPDcf);
- Dv->SetVisibility(kTRUE);
- Dv->SetLineColor(4);
- Dv->SetLineWidth(1);
- Dwv = new TGeoVolume("ITSspdCentCylA1CDw",Dw,SPDcf);
- Dwv->SetVisibility(kTRUE);
- Dwv->SetLineColor(4);
- Dwv->SetLineWidth(1);
- Dsv = new TGeoVolume("ITSspdCentCylA1Dfill",Ds,SPDfs);
- Dsv->SetVisibility(kTRUE);
- Dsv->SetLineColor(3); // Green
- Dsv->SetFillColor(Dsv->GetLineColor());
- Dsv->SetFillStyle(4010); // 10% transparent
- Dwsv = new TGeoVolume("ITSspdCentCylA1DwingFill",Dws,SPDfs);
- Dwsv->SetVisibility(kTRUE);
- Dwsv->SetLineColor(3); // Green
- Dwsv->SetFillColor(Dwsv->GetLineColor());
- Dwsv->SetFillStyle(4010); // 10% transparent
- //
- A1v->AddNode(Ah1v,1,0);
- A2v->AddNode(Ah2v,1,0);
- A3v->AddNode(Ah3v,1,0);
- B1v->AddNode(Bh1v,1,0);
- B2v->AddNode(Bh2v,1,0);
- B3v->AddNode(Bh3v,1,0);
- C1v->AddNode(Ch1v,1,0);
- C2v->AddNode(Ch2v,1,0);
- C3v->AddNode(Ch3v,1,0);
- Dv ->AddNode(Dsv ,1,0);
- Dwv->AddNode(Dwsv,1,0);
- //
- Mv->AddNode(A1v,1,0);
- Mv->AddNode(A2v,1,0);
- Mv->AddNode(A3v,1,0);
- tranb = new TGeoTranslation("",0.0,0.0,0.5*(TSCLengthA+TSCLengthB));
- tranbm = new TGeoTranslation("",0.0,0.0,0.5*(-TSCLengthA-TSCLengthB));
- Mv->AddNode(B1v,1,tranb);
- Mv->AddNode(B2v,1,tranb);
- Mv->AddNode(B3v,1,tranb);
- Mv->AddNode(B1v,2,tranbm);
- Mv->AddNode(B2v,2,tranbm);
- Mv->AddNode(B3v,2,tranbm);
- // Muon side (rb26) is at -Z.
- tranc = new TGeoTranslation("",0.0,0.0,
- 0.5*(-TSCLengthA-TSCLengthB-TSCLengthC));
- Mv->AddNode(C1v,1,tranc);
- Mv->AddNode(C2v,1,tranc);
- Mv->AddNode(C3v,1,tranc);
- Mv->AddNode(Dv,1,tranITSspdShealdVVt0);
- Mv->AddNode(Dwv,1,tranITSspdShealdVVt0);
- Mv->AddNode(Dwv,2,rotITSspdShealdVVt1);
- Mv->AddNode(Dwv,3,rotITSspdShealdVVt2);
- Mv->AddNode(Dwv,4,rotITSspdShealdVVt3);
- k=2;
- for(i=1;i<10;i++) {
- th = ((Double_t)i)*TSCAngle*kDegree;
- rot = new TGeoRotation("",0.0,0.0,th);
- Mv->AddNode(A1v,i+1,rot);
- Mv->AddNode(B1v,i+2,new TGeoCombiTrans(*tranb,*rot));
- Mv->AddNode(B1v,i+12,new TGeoCombiTrans(*tranbm,*rot));
- Mv->AddNode(C1v,i+1,new TGeoCombiTrans(*tranc,*rot));
- if(i!=0||i!=2||i!=7){
- Mv->AddNode(A2v,k++,rot);
- Mv->AddNode(B2v,k++,new TGeoCombiTrans(*tranb,*rot));
- Mv->AddNode(B2v,k++,new TGeoCombiTrans(*tranbm,*rot));
- Mv->AddNode(C2v,k++,new TGeoCombiTrans(*tranc,*rot));
- } // end if
- if(i==5) {
- Mv->AddNode(A3v,2,rot);
- Mv->AddNode(B3v,3,new TGeoCombiTrans(*tranb,*rot));
- Mv->AddNode(B3v,4,new TGeoCombiTrans(*tranbm,*rot));
- Mv->AddNode(C3v,2,new TGeoCombiTrans(*tranc,*rot));
- } // end if
- } // end for i
- rot = new TGeoRotation("",180.,0.0,0.0);
- Mv->AddNode(A3v,3,rot);
- Mv->AddNode(B3v,5,new TGeoCombiTrans(*tranb,*rot));
- Mv->AddNode(B3v,6,new TGeoCombiTrans(*tranbm,*rot));
- Mv->AddNode(C3v,3,new TGeoCombiTrans(*tranc,*rot));
- rot = new TGeoRotation("",180.,0.0,180.0);
- Mv->AddNode(A3v,4,rot);
- Mv->AddNode(B3v,7,new TGeoCombiTrans(*tranb,*rot));
- Mv->AddNode(B3v,8,new TGeoCombiTrans(*tranbm,*rot));
- Mv->AddNode(C3v,4,new TGeoCombiTrans(*tranc,*rot));
- if(GetDebug()){
- A1v->PrintNodes();
- Ah1v->PrintNodes();
- A2v->PrintNodes();
- Ah2v->PrintNodes();
- A3v->PrintNodes();
- Ah3v->PrintNodes();
- B1v->PrintNodes();
- Bh1v->PrintNodes();
- B2v->PrintNodes();
- Bh2v->PrintNodes();
- B3v->PrintNodes();
- Bh3v->PrintNodes();
- C1v->PrintNodes();
- Ch1v->PrintNodes();
- C2v->PrintNodes();
- Ch2v->PrintNodes();
- C3v->PrintNodes();
- Ch3v->PrintNodes();
- Dv->PrintNodes();
- Dsv->PrintNodes();
- Dwv->PrintNodes();
- Dwsv->PrintNodes();
- //Mv->PrintNodes();
- } // end if
+void AliITSv11GeometrySupport::CreateSPDOmegaShape(
+ const Double_t *xin, const Double_t *yin, Double_t d,
+ Double_t *x, Double_t *y)
+{
+//
+// Creates the proper sequence of X and Y coordinates to determine
+// 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::SDDCone(TGeoVolume *Moth){
- // Define the detail SDD support cone geometry.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- //
- // From Cilindro Centrale - Lavorazioni, ALR 0816/1 04/08/03 File
- // name SDD/Cilindro.hpgl
- const Double_t TSLength = 790.0*kmm; // Thermal Sheeld length
- const Double_t TSInsertoLength= 15.0*kmm; // ????
- const Double_t TSOuterR = 0.5*(220.+10.)*kmm; // ????
- const Double_t TSInnerR = 0.5*(220.-10.)*kmm; // ????
- const Double_t TSCarbonFiberth= 0.02*kmm; // ????
- const Double_t TSBoltDiameter = 6.0*kmm; // M6 screw
- const Double_t TSBoltDepth = 6.0*kmm; // in volume C
- const Double_t TSBoltRadius = 0.5*220.*kmm; // Radius in volume C
- const Double_t TSBoltAngle0 = 0.0*kDegree; // Angle in volume C
- const Double_t TSBoltdAngle = 30.0*kDegree; // Angle in Volume C
- Double_t x,y,z,t,t0;
- Int_t i,n;
- TGeoTube *A,*B,*C,*D;
- TGeoTranslation *tran;
- TGeoRotation *rot;
- TGeoCombiTrans *rotran;
- TGeoMedium *SDDcf,*SDDfs,*SDDfo,*SDDss;
-
- A = new TGeoTube("ITS SDD Central Cylinder",TSInnerR,TSOuterR,
- 0.5*TSLength);
- B = new TGeoTube("ITS SDD CC Foam",TSInnerR+TSCarbonFiberth,
- TSOuterR-TSCarbonFiberth,
- 0.5*(TSLength-2.0*TSInsertoLength));
- C = new TGeoTube("ITS SDD CC Inserto",TSInnerR+TSCarbonFiberth,
- TSOuterR-TSCarbonFiberth,0.5*TSLength);
- D = new TGeoTube("ITS SDD CC M6 bolt end",0.0,0.5*TSBoltDiameter,
- 0.5*TSBoltDepth);
- printTube(A);
- printTube(B);
- printTube(C);
- printTube(D);
- //
- TGeoManager *mgr = gGeoManager;
- SDDcf = mgr->GetMedium("ITSssdCarbonFiber");
- SDDfs = mgr->GetMedium("ITSssdStaselite4411w");
- SDDfo = mgr->GetMedium("ITSssdRohacell50A");
- SDDss = mgr->GetMedium("ITSssdStainlessSteal");
- TGeoVolume *Av,*Bv,*Cv,*Dv;
- Av = new TGeoVolume("ITSsddCentCylCF",A,SDDcf);
- Av->SetVisibility(kTRUE);
- Av->SetLineColor(4);
- Av->SetLineWidth(1);
- Av->SetFillColor(Av->GetLineColor());
- Av->SetFillStyle(4000); // 0% transparent
- Bv = new TGeoVolume("ITSsddCentCylF",B,SDDfo);
- Bv->SetVisibility(kTRUE);
- Bv->SetLineColor(3);
- Bv->SetLineWidth(1);
- Bv->SetFillColor(Bv->GetLineColor());
- Bv->SetFillStyle(4000); // 0% transparent
- Cv = new TGeoVolume("ITSsddCentCylSt",C,SDDfs);
- Cv->SetVisibility(kTRUE);
- Cv->SetLineColor(2);
- Cv->SetLineWidth(1);
- Cv->SetFillColor(Cv->GetLineColor());
- Cv->SetFillStyle(4000); // 0% transparent
- Dv = new TGeoVolume("ITSsddCentCylSS",D,SDDss);
- Dv->SetVisibility(kTRUE);
- Dv->SetLineColor(1);
- Dv->SetLineWidth(1);
- Dv->SetFillColor(Dv->GetLineColor());
- Dv->SetFillStyle(4000); // 0% transparent
- //
- Moth->AddNode(Av,1,0);
- Av->AddNode(Cv,1,0);
- Cv->AddNode(Bv,1,0);
- n = (Int_t)((360.*kDegree)/TSBoltdAngle);
- for(i=0;i<n;i++){
- t = TSBoltAngle0+((Double_t)i)*TSBoltdAngle;
- x = TSBoltRadius*TMath::Cos(t*kRadian);
- y = TSBoltRadius*TMath::Sin(t*kRadian);
- z = 0.5*(TSLength-TSBoltDepth);
- tran = new TGeoTranslation("",x,y,z);
- Cv->AddNode(Dv,i+1,tran);
- tran = new TGeoTranslation("",x,y,-z);
- Cv->AddNode(Dv,i+n+1,tran);
- } // end for i
- if(GetDebug()){
- Av->PrintNodes();
- Bv->PrintNodes();
- Cv->PrintNodes();
- Dv->PrintNodes();
- } // end if
- // SDD Suport Cone
- //
- //
- const Double_t Thickness = 10.5*kmm; // Thickness of Rohacell+carbon fiber
- const Double_t Cthick = 1.5*kmm; // Carbon finber thickness
- const Double_t Rcurv = 15.0*kmm; // Radius of curvature.
- const Double_t Tc = 45.0; // angle of SDD cone [degrees].
- const Double_t Sintc = TMath::Sin(Tc*TMath::DegToRad());
- const Double_t Costc = TMath::Cos(Tc*TMath::DegToRad());
- const Double_t Tantc = TMath::Tan(Tc*TMath::DegToRad());
- const Double_t ZouterMilled = 23.0*kmm;
- const Double_t Zcylinder = 186.0*kmm;
- const Double_t Z0 = Zcylinder + 0.5*TSLength;
- //const Int_t Nspoaks = 12;
- //const Int_t Nmounts = 4;
- //const Double_t DmountAngle = 9.0; // degrees
- const Double_t RoutMax = 0.5*560.0*kmm;
- const Double_t RoutMin = 0.5*539.0*kmm;
- // Holes in cone for cables
- const Double_t PhiHole1 = 0.0*kDegree;
- const Double_t dPhiHole1 = 25.0*kDegree;
- const Double_t RholeMax1 = 0.5*528.*kmm;
- const Double_t RholeMin1 = 0.5*464.*kmm;
- const Double_t PhiHole2 = 0.0*kDegree;
- const Double_t dPhiHole2 = 50.0*kDegree;
- const Double_t RholeMax2 = 0.5*375.*kmm;
- const Double_t RholeMin2 = 0.5*280.*kmm;
- //
- //const Int_t NpostsOut = 6;
- //const Int_t NpostsIn = 3;
- //const Double_t Phi0PostOut = 0.0; // degree
- //const Double_t Phi0PostIn = 0.0; // degree
- //const Double_t dRpostOut = 16.0*kmm;
- //const Double_t dRpostIn = 16.0*kmm;
- //const Double_t ZpostMaxOut = 116.0*kmm;
- //const Double_t ZpostMaxIn = 190.0*kmm;
- const Double_t RinMax = 0.5*216*kmm;
- const Double_t RinCylinder = 0.5*231.0*kmm;
- //const Double_t RinHole = 0.5*220.0*kmm;
- const Double_t RinMin = 0.5*210.0*kmm;
- const Double_t dZin = 15.0*kmm; // ???
- //
- Double_t dza = Thickness/Sintc-(RoutMax-RoutMin)/Tantc;
- Double_t Z,Rmin,Rmax; // Temp variables.
- 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
- TGeoPcon *E = new TGeoPcon("ITSsddSuportConeCarbonFiberSurfaceE",
- 0.0,360.0,12);
- E->Z(0) = 0.0;
- E->Rmin(0) = RoutMin;
- E->Rmax(0) = RoutMax;
- E->Z(1) = ZouterMilled - dza;
- E->Rmin(1) = E->GetRmin(0);
- E->Rmax(1) = E->GetRmax(0);
- E->Z(2) = ZouterMilled;
- E->Rmax(2) = E->GetRmax(0);
- RadiusOfCurvature(Rcurv,0.,E->GetZ(1),E->GetRmin(1),Tc,Z,Rmin);
- E->Z(3) = Z;
- E->Rmin(3) = Rmin;
- E->Rmin(2) = RminFrom2Points(E,3,1,E->GetZ(2));
- RadiusOfCurvature(Rcurv,0.,E->GetZ(2),E->GetRmax(2),Tc,Z,Rmax);
- E->Z(4) = Z;
- E->Rmax(4) = Rmax;
- E->Rmin(4) = RminFromZpCone(E,Tc,E->GetZ(4),0.0);
- E->Rmax(3) = RmaxFrom2Points(E,4,2,E->GetZ(3));
- E->Rmin(7) = RinMin;
- E->Rmin(8) = RinMin;
- RadiusOfCurvature(Rcurv,90.0,0.0,RinMax,90.0-Tc,Z,Rmax);
- E->Rmax(8) = Rmax;
- E->Z(8) = ZFromRmaxpCone(E,Tc,E->GetRmax(8));
- E->Z(9) = Zcylinder;
- E->Rmin(9) = RinMin;
- E->Z(10) = E->GetZ(9);
- E->Rmin(10) = RinCylinder;
- E->Rmin(11) = RinCylinder;
- E->Rmax(11) = E->GetRmin(11);
- Rmin = E->GetRmin(8);
- RadiusOfCurvature(Rcurv,90.0-Tc,E->GetZ(8),E->GetRmax(8),90.0,Z,Rmax);
- Rmax = RinMax;
- E->Z(11) = Z+(E->GetZ(8)-Z)*(E->GetRmax(11)-Rmax)/(E->GetRmax(8)-Rmax);
- E->Rmax(9) = RmaxFrom2Points(E,11,8,E->GetZ(9));
- E->Rmax(10) = E->GetRmax(9);
- E->Z(6) = Z-dZin;
- E->Z(7) = E->GetZ(6);
- E->Rmax(6) = RmaxFromZpCone(E,Tc,E->GetZ(6));
- E->Rmax(7) = E->GetRmax(6);
- RadiusOfCurvature(Rcurv,90.,E->GetZ(6),0.0,90.0-Tc,Z,Rmin);
- E->Z(5) = Z;
- E->Rmin(5) = RminFromZpCone(E,Tc,Z);
- E->Rmax(5) = RmaxFromZpCone(E,Tc,Z);
- RadiusOfCurvature(Rcurv,90.-Tc,0.0,E->Rmin(5),90.0,Z,Rmin);
- E->Rmin(6) = Rmin;
- printPcon(E);
- // Inner Core, Inserto material
- TGeoPcon *F = new TGeoPcon("ITSsddSuportConeInsertoStesaliteF",
- 0.,360.0,9);
- F->Z(0) = E->GetZ(0);
- F->Rmin(0) = E->GetRmin(0)+Cthick;
- F->Rmax(0) = E->GetRmax(0)-Cthick;
- F->Z(1) = E->GetZ(1);
- F->Rmin(1) = F->GetRmin(0);
- F->Rmax(1) = F->GetRmax(0);
- F->Z(2) = E->GetZ(2);
- F->Rmax(2) = F->GetRmax(1);
- RadiusOfCurvature(Rcurv-Cthick,0.,F->GetZ(1),F->GetRmax(1),Tc,Z,Rmin);
- F->Z(3) = Z;
- F->Rmin(3) = Rmin;
- F->Rmin(2) = RminFrom2Points(F,3,1,F->GetZ(2));
- RadiusOfCurvature(Rcurv+Cthick,0.,F->GetZ(2),F->GetRmax(2),Tc,Z,Rmax);
- F->Z(4) = Z;
- F->Rmax(4) = Rmax;
- F->Rmin(4) = RmaxFromZpCone(E,Tc,F->GetZ(4),-Cthick);
- F->Rmax(3) = RmaxFrom2Points(F,4,2,F->GetZ(3));
- F->Rmin(7) = E->GetRmin(7);
- F->Rmin(8) = E->GetRmin(8);
- F->Z(6) = E->GetZ(6)+Cthick;
- F->Rmin(6) = E->GetRmin(6);
- F->Z(7) = F->GetZ(6);
- F->Rmax(8) = E->GetRmax(8)-Cthick*Sintc;
- RadiusOfCurvature(Rcurv+Cthick,90.0,F->GetZ(6),F->GetRmin(6),90.0-Tc,
- Z,Rmin);
- F->Z(5) = Z;
- F->Rmin(5) = Rmin;
- F->Rmax(5) = RmaxFromZpCone(F,Tc,Z);
- F->Rmax(6) = RmaxFromZpCone(F,Tc,F->GetZ(6));
- F->Rmax(7) = F->GetRmax(6);
- F->Z(8) = ZFromRmaxpCone(F,Tc,F->GetRmax(8),-Cthick);
- printPcon(F);
- // Inner Core, Inserto material
- TGeoPcon *G = new TGeoPcon("ITSsddSuportConeFoamCoreG",0.0,360.0,4);
- RadiusOfCurvature(Rcurv+Cthick,0.0,F->GetZ(1),F->GetRmin(1),Tc,Z,Rmin);
- G->Z(0) = Z;
- G->Rmin(0) = Rmin;
- G->Rmax(0) = G->GetRmin(0);
- G->Z(1) = G->GetZ(0)+(Thickness-2.0*Cthick)/Sintc;;
- G->Rmin(1) = RminFromZpCone(F,Tc,G->GetZ(1));
- G->Rmax(1) = RmaxFromZpCone(F,Tc,G->GetZ(1));
- G->Z(2) = E->GetZ(5)-Cthick;
- G->Rmin(2) = RminFromZpCone(F,Tc,G->GetZ(2));
- G->Rmax(2) = RmaxFromZpCone(F,Tc,G->GetZ(2));
- G->Z(3) = F->GetZ(5)+(Thickness-2.0*Cthick)*Costc;
- G->Rmax(3) = RmaxFromZpCone(F,Tc,G->GetZ(3));
- G->Rmin(3) = G->GetRmax(3);
- printPcon(G);
- //
- TGeoPcon *H = new TGeoPcon("ITSsddSuportConeHoleH",PhiHole1,dPhiHole1,4);
- H->Rmin(0) = RholeMax1;
- H->Rmax(0) = H->GetRmin(0);
- H->Z(0) = ZFromRminpCone(E,Tc,H->GetRmin(0));
- H->Rmax(1) = H->GetRmax(0);
- H->Z(1) = ZFromRmaxpCone(E,Tc,H->GetRmax(1));
- H->Rmin(1) = RminFromZpCone(E,Tc,H->GetZ(1));
- H->Rmin(2) = RholeMin1;
- H->Z(2) = ZFromRminpCone(E,Tc,H->GetRmin(2));
- H->Rmax(2) = RmaxFromZpCone(E,Tc,H->GetZ(2));
- H->Rmin(3) = H->GetRmin(2);
- H->Rmax(3) = H->GetRmin(3);
- H->Z(3) = ZFromRminpCone(E,Tc,H->GetRmin(3));
- printPcon(H);
- //
- x = Cthick/(0.5*(RholeMax1+RholeMin1));
- t0 = PhiHole1 - x/kRadian;
- t = dPhiHole1 + 2.0*x/kRadian;
- TGeoPcon *I = new TGeoPcon("ITSsddSuportConeHoleI",t0,t,4);
- I->Rmin(0) = RholeMax1+Cthick;
- I->Rmax(0) = I->GetRmin(0);
- I->Z(0) = ZFromRminpCone(F,Tc,I->GetRmin(0));
- I->Rmax(1) = I->GetRmax(0);
- I->Z(1) = ZFromRmaxpCone(F,Tc,I->GetRmax(1));
- I->Rmin(1) = RminFromZpCone(F,Tc,I->GetZ(1));
- I->Rmin(2) = RholeMin1-Cthick;
- I->Z(2) = ZFromRminpCone(F,Tc,I->GetRmin(2));
- I->Rmax(2) = RmaxFromZpCone(F,Tc,I->GetZ(2));
- I->Rmin(3) = I->GetRmin(2);
- I->Rmax(3) = I->GetRmin(3);
- I->Z(3) = ZFromRmaxpCone(F,Tc,I->GetRmax(3));
- printPcon(I);
- //
- TGeoPcon *J = new TGeoPcon("ITSsddSuportConeHoleJ",PhiHole2,dPhiHole2,4);
- J->Rmin(0) = RholeMax2;
- J->Rmax(0) = J->GetRmin(0);
- J->Z(0) = ZFromRminpCone(E,Tc,J->GetRmin(0));
- J->Rmax(1) = J->GetRmax(0);
- J->Z(1) = ZFromRmaxpCone(E,Tc,J->GetRmax(1));
- J->Rmin(1) = RminFromZpCone(E,Tc,J->GetZ(1));
- J->Rmin(2) = RholeMin2;
- J->Z(2) = ZFromRminpCone(E,Tc,J->GetRmin(2));
- J->Rmax(2) = RmaxFromZpCone(E,Tc,J->GetZ(2));
- J->Rmin(3) = J->GetRmin(2);
- J->Rmax(3) = J->GetRmin(3);
- J->Z(3) = ZFromRmaxpCone(E,Tc,J->GetRmax(3));
- printPcon(J);
- //
- x = Cthick/(0.5*(RholeMax2+RholeMin2));
- t0 = PhiHole2 - x/kRadian;
- t = dPhiHole2 + 2.0*x/kRadian;
- TGeoPcon *K = new TGeoPcon("ITSsddSuportConeHoleK",t0,t,4);
- K->Rmin(0) = RholeMax2+Cthick;
- K->Rmax(0) = K->GetRmin(0);
- K->Z(0) = ZFromRminpCone(F,Tc,K->GetRmin(0));
- K->Rmax(1) = K->GetRmax(0);
- K->Z(1) = ZFromRmaxpCone(F,Tc,K->GetRmax(1));
- K->Rmin(1) = RminFromZpCone(F,Tc,K->GetZ(1));
- K->Rmin(2) = RholeMin2-Cthick;
- K->Z(2) = ZFromRminpCone(F,Tc,K->GetRmin(2));
- K->Rmax(2) = RmaxFromZpCone(F,Tc,K->GetZ(2));
- K->Rmin(3) = K->GetRmin(2);
- K->Rmax(3) = K->GetRmin(3);
- K->Z(3) = ZFromRmaxpCone(F,Tc,K->GetRmax(3));
- printPcon(K);
- //
- TGeoCompositeShape *L,*M,*N;
- rot = new TGeoRotation("ITSsddRotZ30",0.0,0.0,30.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ60",0.0,0.0,60.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ90",0.0,0.0,90.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ120",0.0,0.0,120.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ150",0.0,0.0,150.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ180",0.0,0.0,180.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ210",0.0,0.0,210.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ240",0.0,0.0,240.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ270",0.0,0.0,270.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ300",0.0,0.0,300.0);
- rot->RegisterYourself();
- rot = new TGeoRotation("ITSsddRotZ330",0.0,0.0,330.0);
- rot->RegisterYourself();
- L = 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");
- M = 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");
- N = 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");
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- TGeoVolume *Lv,*Mv,*Nv;
- Lv = new TGeoVolume("ITSsddConeL",L,SDDcf);
- Lv->SetVisibility(kTRUE);
- Lv->SetLineColor(4);
- Lv->SetLineWidth(1);
- Lv->SetFillColor(Lv->GetLineColor());
- Lv->SetFillStyle(4000); // 0% transparent
- Mv = new TGeoVolume("ITSsddConeM",M,SDDfs);
- Mv->SetVisibility(kTRUE);
- Mv->SetLineColor(2);
- Mv->SetLineWidth(1);
- Mv->SetFillColor(Mv->GetLineColor());
- Mv->SetFillStyle(4010); // 10% transparent
- Nv = new TGeoVolume("ITSsddConeN",N,SDDfo);
- Nv->SetVisibility(kTRUE);
- Nv->SetLineColor(7);
- Nv->SetLineWidth(1);
- Nv->SetFillColor(Nv->GetLineColor());
- Nv->SetFillStyle(4050); // 50% transparent
- //
- Mv->AddNode(Nv,1,0);
- Lv->AddNode(Mv,1,0);
- tran = new TGeoTranslation("",0.0,0.0,-Z0);
- Moth->AddNode(Lv,1,tran);
- rot = new TGeoRotation("",0.0,180.0*kDegree,0.0);
- rotran = new TGeoCombiTrans("",0.0,0.0,Z0,rot);
- delete rot;// rot not explicity used in AddNode functions.
- Moth->AddNode(Lv,2,rotran);
- if(GetDebug()){
- Lv->PrintNodes();
- Mv->PrintNodes();
- Nv->PrintNodes();
- } // end if
+void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
+ Double_t r, Double_t t,
+ Double_t *x, Double_t *y) const
+{
+//
+// 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::SSDCone(TGeoVolume *Moth){
- // Define the detail SSD support cone geometry.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- //
- Int_t i,j;
- Double_t t,t0,dt,x,y,z,vl[3],vg[3],x0,y0;
- TGeoMedium *SSDcf = 0; // SSD support cone Carbon Fiber materal number.
- TGeoMedium *SSDfs = 0; // SSD support cone inserto stesalite 4411w.
- TGeoMedium *SSDfo = 0; // SSD support cone foam, Rohacell 50A.
- TGeoMedium *SSDss = 0; // SSD support cone screw material,Stainless steal
- TGeoMedium *SSDair = 0; // SSD support cone Air
- TGeoMedium *SSDal = 0; // SSD support cone SDD mounting bracket Al
- TGeoManager *mgr = gGeoManager;
- SSDcf = mgr->GetMedium("ITSssdCarbonFiber");
- SSDfs = mgr->GetMedium("ITSssdStaselite4411w");
- SSDfo = mgr->GetMedium("ITSssdRohacell50A");
- SSDss = mgr->GetMedium("ITSssdStainlessSteal");
- SSDair= mgr->GetMedium("ITSssdAir");
- SSDal = mgr->GetMedium("ITSssdAl");
- //
- // SSD Central cylinder/Thermal Sheald.
- const Double_t CylZlength = 1140.0*kmm; //
- const Double_t CylZFoamlength = 1020.0*kmm; //
- const Double_t CylROuter = 0.5*595.0*kmm; //
- const Double_t CylRInner = 0.5*560.5*kmm; //
- const Double_t CylCthick = 0.64*kmm; //
- const Double_t CylFoamThick = 5.0*kmm; //
- const Double_t CylRholes = 0.5*575.0*kmm;
- const Double_t CylZM6 = 6.0*kmm; //
- const Double_t CylRM6 = 0.5*6.0*kmm;
- const Double_t CylPhi0M6 = 0.0*kDegree;
- const Int_t CylNM6 = 40;
- const Double_t CylZPin = 10.0*kmm;
- const Double_t CylRPin = 0.5*4.0*kmm;
- const Double_t CylPhi0Pin = (90.0+4.5)*kDegree;
- const Int_t CylNPin = 2;
- //
- //Begin_Html
- /*
- <img src="picts/ITS/file_name.gif">
- <P>
- <FONT FACE'"TIMES">
- ITS SSD centreal support and thermal sheal cylinder.
- </FONT>
- </P>
- */
- //End_Html
- TGeoPcon *CA = new TGeoPcon("ITS SSD Thermal Centeral Carbon Fiber "
- "CylinderCA",0.0,360.0,6);
- TGeoPcon *CB = new TGeoPcon("ITS SSD Thermal Centeral Stesalite "
- "CylinderCB",0.0,360.0,6);
- TGeoTube *CC = new TGeoTube("ITS SSD Thermal Centeral Rohacell "
- "CylinderCC",
- CylROuter-CylCthick-CylFoamThick,
- CylROuter-CylCthick,0.5*CylZFoamlength);
- CA->Z(0) = -0.5*CylZlength;
- CA->Rmin(0) = CylRInner;
- CA->Rmax(0) = CylROuter;
- CA->Z(1) = CA->GetZ(0) + CylZM6;
- CA->Rmin(1) = CA->GetRmin(0);
- CA->Rmax(1) = CA->GetRmax(0);
- CA->Z(2) = -0.5*CylZFoamlength;
- CA->Rmin(2) = CylROuter - 2.0*CylCthick-CylFoamThick;
- CA->Rmax(2) = CA->GetRmax(0);
- CA->Z(3) = -CA->GetZ(2);
- CA->Rmin(3) = CA->GetRmin(2);
- CA->Rmax(3) = CA->GetRmax(2);
- CA->Z(4) = -CA->GetZ(1);
- CA->Rmin(4) = CA->GetRmin(1);
- CA->Rmax(4) = CA->GetRmax(1);
- CA->Z(5) = -CA->GetZ(0);
- CA->Rmin(5) = CA->GetRmin(0);
- CA->Rmax(5) = CA->GetRmax(0);
- //
- CB->Z(0) = CA->GetZ(0);
- CB->Rmin(0) = CA->GetRmin(0) + CylCthick;
- CB->Rmax(0) = CA->GetRmax(0) - CylCthick;
- CB->Z(1) = CA->GetZ(1);
- CB->Rmin(1) = CA->GetRmin(1) + CylCthick;
- CB->Rmax(1) = CA->GetRmax(1) - CylCthick;
- CB->Z(2) = CA->GetZ(2);
- CB->Rmin(2) = CA->GetRmin(2) + CylCthick;
- CB->Rmax(2) = CA->GetRmax(2) - CylCthick;
- CB->Z(3) = CA->GetZ(3);
- CB->Rmin(3) = CA->GetRmin(3) + CylCthick;
- CB->Rmax(3) = CA->GetRmax(3) - CylCthick;
- CB->Z(4) = CA->GetZ(4);
- CB->Rmin(4) = CA->GetRmin(4) + CylCthick;
- CB->Rmax(4) = CA->GetRmax(4) - CylCthick;
- CB->Z(5) = CA->GetZ(5);
- CB->Rmin(5) = CA->GetRmin(5) + CylCthick;
- CB->Rmax(5) = CA->GetRmax(5) - CylCthick;
- //
- printPcon(CA);
- printPcon(CB);
- printTube(CC);
- //
- TGeoTube *CD = new TGeoTube("ITS SSD Thermal Centeral Cylinder M6 screwCD",
- 0.0,CylRM6,0.5*CylZM6);
- TGeoTube *CE = new TGeoTube("ITS SSD Thermal Centeral Cylinder PinCE",
- 0.0,CylRPin,0.5*CylZPin);
- //
- TGeoVolume *CAv,*CBv,*CCv,*CDv,*CEv;
- CAv = new TGeoVolume("ITSssdCentCylCA",CA,SSDcf);
- CAv->SetVisibility(kTRUE);
- CAv->SetLineColor(4); // blue
- CAv->SetLineWidth(1);
- CAv->SetFillColor(CAv->GetLineColor());
- CAv->SetFillStyle(4000); // 0% transparent
- CBv = new TGeoVolume("ITSssdCentCylCB",CB,SSDfs);
- CBv->SetVisibility(kTRUE);
- CBv->SetLineColor(2); // red
- CBv->SetLineWidth(1);
- CBv->SetFillColor(CBv->GetLineColor());
- CBv->SetFillStyle(4050); // 50% transparent
- CCv = new TGeoVolume("ITSssdCentCylCC",CC,SSDfo);
- CCv->SetVisibility(kTRUE);
- CCv->SetLineColor(3); // green
- CCv->SetLineWidth(1);
- CCv->SetFillColor(CCv->GetLineColor());
- CCv->SetFillStyle(4050); // 50% transparent
- CDv = new TGeoVolume("ITSssdCentCylCD",CD,SSDss);
- CDv->SetVisibility(kTRUE);
- CDv->SetLineColor(1); // black
- CDv->SetLineWidth(1);
- CDv->SetFillColor(CDv->GetLineColor());
- CDv->SetFillStyle(4000); // 0% transparent
- CEv = new TGeoVolume("ITSssdCentCylCE",CE,SSDss);
- CEv->SetVisibility(kTRUE);
- CEv->SetLineColor(1); // black
- CEv->SetLineWidth(1);
- CEv->SetFillColor(CEv->GetLineColor());
- CEv->SetFillStyle(4000); // 0% transparent
- // Insert Bolt and Pins in both the Cone and Cylinder at the same time.
- CBv->AddNode(CCv,1,0);
- CAv->AddNode(CBv,1,0);
- Moth->AddNode(CAv,1,0);
- if(GetDebug()){
- CAv->PrintNodes();
- CBv->PrintNodes();
- CCv->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 ConThick = 13.0*kmm; // Thickness of Cone.
- const Double_t ConCthick = 0.75*kmm; // Carbon finber thickness
- const Double_t ConRCurv = 10.0*kmm; // Radius of curvature.
- const Double_t ConT = 39.0*kDegree; // angle of SSD cone.
- const Double_t ConZOuterRing = 47.0*kmm;
- const Double_t ConZOuterRingMill = ConZOuterRing-5.0*kmm;
- const Double_t ConZToCylinder = 170.0*kmm;
- const Double_t ConZLength = 176.5*kmm-
- (ConZOuterRing-ConZOuterRingMill);
- const Double_t ConZInnerRing = 161.5*kmm-
- (ConZOuterRing-ConZOuterRingMill);
- const Double_t ConZOuterRingInside = 30.25*kmm-
- (ConZOuterRing-ConZOuterRingMill);
- const Double_t ConZDisplacement = ConZToCylinder + 0.5*CylZlength;
- const Double_t ConROuterMax = 0.5*985.0*kmm;
- const Double_t ConROuterMin = 0.5*945.0*kmm;
- const Double_t ConRCylOuterMill = 0.5*597.0*kmm;
- const Double_t ConRInnerMin = 0.5*564.0*kmm;
- const Double_t ConRCentCurv0 = 0.5*927.0*kmm;
- const Double_t ConRCentCurv1 = 0.5*593.0*kmm;
- //const Double_t ConRCentCurv2 = 0.5*578.0*kmm;
- // Foam core.
- const Double_t ConRohacellL0 = 112.3*kmm;
- const Double_t ConRohacellL1 = 58.4*kmm;
- // Screws and pins in outer SSD cone ring
- const Double_t ConROutHoles = 0.5*965.0*kmm;
- const Double_t ConRScrewM5by12 = 0.5*5.0*kmm;
- const Double_t ConLScrewM5by12 = 0.5*12.0*kmm;
- const Int_t ConNScrewM5by12 = 2;
- const Double_t ConRPinO6 = 0.5*6.0*kmm;
- const Double_t ConLPinO6 = 0.5*10.0*kmm;
- const Int_t ConNPinO6 = 3;
- const Int_t ConNRailScrews = 4;
- const Int_t ConNRailPins = 2;
- const Int_t ConNmounts = 4;
- const Double_t ConMountPhi0 = 9.0*kDegree; // degrees
- // Holes in SSD cone, Ch* Cable Hole, Th* Tubing hole, and
- // Mh* mounting-post holes
- const Double_t ConCableHoleROut = 0.5*920.0*kmm;
- const Double_t ConCableHoleRinner = 0.5*800.0*kmm;
- const Double_t ConCableHoleWidth = 200.0*kmm;
- const Double_t ConCableHoleAngle = 42.0*kDegree;
- //const Double_t ConCableHolePhi0 = 90.0/4.0*kDegree;
- //const Int_t ConNCableHoles = 8;
- const Double_t ConCoolHoleWidth = 40.0*kmm;
- const Double_t ConCoolHoleHight = 30.0*kmm;
- const Double_t ConCoolHoleRmin = 350.0*kmm;
- //const Double_t ConCoolHolephi0 = 90.0/4.0*kDegree;
- //const Int_t ConNCoolHoles = 8;
- const Double_t ConMountHoleWidth = 20.0*kmm;
- const Double_t ConMountHoleHight = 20.0*kmm;
- const Double_t ConMountHoleRmin = 317.5*kmm;
- //const Double_t ConMountHolephi0 = 0.0*kDegree;
- //const Int_t ConNMountHoles = 6;
- // SSD cone Wings with holes.
- const Double_t ConWingRmax = 527.5*kmm;
- const Double_t ConWingWidth = 70.0*kmm;
- const Double_t ConWingThick = 10.0*kmm;
- const Double_t ConWingPhi0 = 45.0*kDegree;
- //const Int_t ConNWings = 4;
- // SSD-SDD Thermal/Mechanical cylinder mounts
- const Double_t ConRM6Head = 8.0*kmm;
- const Double_t ConZM6Head = 8.5*kmm;
- //
- // SSD-SDD Mounting bracket
- const Double_t SupPRmin = 0.5*539.0*kmm;// see SDD RoutMin
- const Double_t SupPRmax = 0.5*585.0*kmm;
- const Double_t SupPZ = 3.5*kmm;
- const Double_t SupPPhi1 = -0.5*70.0*kmm/SupPRmax*kRadian;
- const Double_t SupPPhi2 = -SupPPhi1;
- //
- const Double_t Sintc = TMath::Sin(ConT*kRadian);
- const Double_t Costc = TMath::Cos(ConT*kRadian);
- //
- // 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<=ConT and
- // za = za[2] + r*Cosd(t) for 0<=t<=ConT. 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<=ConT and za = za[1]+r&Sind(t)
- // for t<=0<=ConT. These curves have been replaced by straight lines
- // between the equivelent points for simplicity.
- // Poly-cone Volume A0. Top part of SSD cone Carbon Fiber.
- TGeoPcon *A0 = new TGeoPcon("ITSssdSuportConeCarbonFiberSurfaceA0",
- 0.0,360.0,15);
- A0->Z(0) = 0.0;
- A0->Rmin(0) = ConROuterMin;
- A0->Rmax(0) = ConROuterMax;
- A0->Z(1) = ConZOuterRingInside-ConRCurv;
- A0->Rmin(1) = A0->GetRmin(0);
- A0->Rmax(1) = A0->GetRmax(0);
- A0->Z(2) = ConZOuterRingInside;
- A0->Rmin(2) = ConROuterMin-ConRCurv;
- A0->Rmax(2) = A0->GetRmax(0);
- A0->Z(3) = A0->GetZ(2);
- A0->Rmin(3) = -1000; // See Below
- A0->Rmax(3) = A0->GetRmax(0);
- A0->Z(4) = ConZOuterRingMill-ConRCurv;
- A0->Rmin(4) = -1000; // See Below
- A0->Rmax(4) = A0->GetRmax(0);
- A0->Z(5) = ConZOuterRingMill;
- A0->Rmin(5) = -1000; // See Below
- A0->Rmax(5) = A0->GetRmax(0) - ConRCurv;
- A0->Z(6) = A0->GetZ(5);
- A0->Rmin(6) = -1000; // See Below
- A0->Rmax(6) = ConRCentCurv0;
- A0->Z(7) = ConZOuterRingMill+ConRCurv*Sintc;
- A0->Rmin(7) = -1000; // See Below
- A0->Rmax(7) = ConRCentCurv0-ConRCurv*Costc;
- A0->Z(8) = -1000; // See Below
- A0->Rmin(8) = ConRInnerMin;
- A0->Rmax(8) = -1000; // See Below
- A0->Z(9) = ConZInnerRing;
- A0->Rmin(9) = -1000; // See Below
- A0->Rmax(9) = -1000; // See Below
- A0->Z(10) = ConZInnerRing;
- A0->Rmin(10)= ConRInnerMin;
- A0->Rmax(10)= -1000; // See Below
- A0->Z(11) = ConZLength-ConRCurv+ConRCurv*Costc;
- A0->Rmin(11)= ConRInnerMin;
- A0->Rmax(11)= ConRCentCurv1+ConRCurv*Sintc;
- A0->Z(12) = ConZToCylinder;
- A0->Rmin(12)= ConRInnerMin;
- A0->Rmax(12)= -1000; // See Below
- A0->Z(13) = ConZToCylinder;
- A0->Rmin(13)= ConRCylOuterMill;
- A0->Rmax(13)= -1000; // See Below
- A0->Z(14) = -1000; // See Below
- A0->Rmin(14)= ConRCylOuterMill;
- A0->Rmax(14)= ConRCylOuterMill;
- // Compute values undefined above.
- RadiusOfCurvature(ConRCurv,0.0,A0->GetZ(9),A0->GetRmin(9),ConT,A0->Z(8),x);
- A0->Rmin(3) = RminFromZpCone(A0,8,90.-ConT,A0->GetZ(3),0.0);
- A0->Rmin(4) = RminFromZpCone(A0,3,90.-ConT,A0->GetZ(4),0.0);
- A0->Rmin(5) = RminFromZpCone(A0,3,90.-ConT,A0->GetZ(5),0.0);
- A0->Rmin(6) = A0->GetRmin(5);
- A0->Rmin(7) = RminFromZpCone(A0,3,90.-ConT,A0->GetZ(7),0.0);
- A0->Rmax(8) = RmaxFromZpCone(A0,4,90.-ConT,A0->GetZ(8),0.0);
- A0->Rmin(9) = RminFromZpCone(A0,3,90.-ConT,A0->GetZ(9),0.0);
- A0->Rmax(9) = RmaxFromZpCone(A0,4,90.-ConT,A0->GetZ(9),0.0);
- A0->Rmax(10)= RmaxFromZpCone(A0,4,90.-ConT,A0->GetZ(10),0.0);
- t = TMath::Tan((270.+ConT)*TMath::DegToRad());
- A0->Z(14) = (ConRCylOuterMill-A0->GetRmax(4)+t*A0->GetZ(4))/t;
- A0->Rmax(12)= RmaxFrom2Points(A0,11,14,A0->GetZ(12));
- A0->Rmax(13)= RmaxFrom2Points(A0,11,14,A0->GetZ(13));
- printPcon(A0);
- //
- // Poly-cone Volume B. Stesalite inside volume A0.
- // Now lets define the Inserto Stesalite 4411w material volume.
- // Poly-cone Volume A0. Top part of SSD cone Carbon Fiber.
- TGeoPcon *B0 = new TGeoPcon("ITSssdSuportConeStaseliteB0",
- 0.0,360.0,15);
- //
- B0->Z(0) = A0->GetZ(0);
- B0->Rmin(0) = A0->GetRmin(0) + ConCthick;
- B0->Rmax(0) = A0->GetRmax(0) - ConCthick;
- InsidePoint(A0,0,1,2,ConCthick,B0,1,kFALSE); // Rmin
- B0->Rmax(1) = B0->Rmax(0);
- InsidePoint(A0,1,2,3,ConCthick,B0,2,kFALSE); // Rmin
- B0->Rmax(2) = B0->Rmax(0);
- InsidePoint(A0,2,3,9,ConCthick,B0,3,kFALSE);
- B0->Rmax(3) = B0->Rmax(0);
- InsidePoint(A0,0,4,5,ConCthick,B0,4,kTRUE); // Rmax
- B0->Rmin(4) = -1000.; // see Bellow
- InsidePoint(A0,4,5,6,ConCthick,B0,5,kTRUE); // Rmax
- B0->Rmin(5) = -1000.; // see Bellow
- InsidePoint(A0,5,6,7,ConCthick,B0,6,kTRUE); // Rmax
- B0->Rmin(6) = -1000.; // see Bellow
- InsidePoint(A0,6,7,11,ConCthick,B0,7,kTRUE); // Rmax
- B0->Rmin(7) = -1000.; // see Bellow
- InsidePoint(A0,3,8,9,ConCthick,B0,8,kFALSE); // Rmin
- B0->Rmax(8) = -1000.; // see Bellow
- InsidePoint(A0,8,9,10,ConCthick,B0,9,kFALSE); // Rmin
- B0->Rmax(9) = -1000.; // see Bellow
- B0->Z(10) = A0->GetZ(10) + ConCthick;
- B0->Rmin(10)= A0->GetRmin(10);
- B0->Rmax(10)= -1000.; // see Bellow
- InsidePoint(A0,7,11,14,ConCthick,B0,11,kTRUE); // Rmax
- B0->Rmin(11)= A0->GetRmin(10);
- B0->Z(2) = A0->GetZ(12);
- B0->Rmin(12)= A0->GetRmin(12);
- B0->Rmax(12)= -1000.; // see Bellow
- B0->Z(13) = A0->GetZ(13);
- B0->Rmin(13)= A0->GetRmin(13);
- B0->Rmax(13)= -1000.; // see Bellow
- B0->Z(14) = A0->GetZ(14) - ConCthick;
- B0->Rmin(14)= A0->GetRmin(14);
- B0->Rmax(14)= B0->Rmin(14); // Close?
- B0->Rmin(4) = RminFrom2Points(B0,3,8,B0->GetZ(4));
- B0->Rmin(5) = RminFrom2Points(B0,3,8,B0->GetZ(5));
- B0->Rmin(6) = B0->GetRmin(5);
- B0->Rmin(7) = RminFrom2Points(B0,3,8,B0->GetZ(7));
- B0->Rmax(8) = RmaxFrom2Points(B0,7,11,B0->GetZ(8));
- B0->Rmax(9) = RmaxFrom2Points(B0,7,11,B0->GetZ(9));
- B0->Rmax(10)= B0->GetRmax(9);
- B0->Rmax(12)= RmaxFrom2Points(B0,11,14,B0->GetZ(12));
- B0->Rmax(13)= RmaxFrom2Points(B0,11,14,B0->GetZ(13));
- printPcon(B0);
- //
- // Poly-cone Volume C0. Foam inside volume A0.
- // Now lets define the Rohacell foam material volume.
- TGeoPcon *C0 = new TGeoPcon("ITSssdSuportConeRohacellC0",
- 0.0,360.0,4);
- C0->Z(1) = B0->GetZ(7);
- C0->Rmax(1) = B0->GetRmax(7);
- C0->Rmin(1) = RminFrom2Points(B0,3,8,C0->GetZ(1));
- C0->Rmin(0) = C0->GetRmax(1);
- C0->Rmax(0) = C0->GetRmin(0);
- C0->Z(0) = Zfrom2MinPoints(B0,3,8,C0->Rmin(0));
- C0->Z(3) = C0->GetZ(0)+(ConThick-2.0*ConCthick+ConRohacellL0)*Costc;
- C0->Rmin(3) = C0->GetRmin(0)+(ConThick-2.0*ConCthick-ConRohacellL0)*Sintc;
- C0->Rmax(3) = C0->GetRmin(3);
- C0->Rmin(2) = C0->GetRmin(3);
- C0->Z(2) = Zfrom2MinPoints(B0,3,8,C0->GetRmin(2));
- C0->Rmax(2) = RmaxFrom2Points(B0,4,11,C0->GetZ(2));
- printPcon(C0);
- //
- // Poly-cone Volume F. Second Foam inside volume A0.
- // Now lets define the Rohacell foam material volume.
- TGeoPcon *F0 = new TGeoPcon("ITSssdSuportConeRohacellCF0",
- 0.0,360.0,4);
- F0->Z(2) = B0->GetZ(8);
- F0->Rmin(2) = B0->GetRmin(8);
- F0->Rmax(2) = B0->GetRmax(8);
- F0->Z(0) = F0->GetZ(2)-ConRohacellL1*Sintc;
- F0->Rmin(0) = F0->GetRmin(2)+ConRohacellL1*Costc;
- F0->Rmax(0) = F0->GetRmin(0);
- F0->Z(1) = Zfrom2MaxPoints(B0,4,11,F0->GetRmax(0));
- F0->Rmax(1) = F0->GetRmax(0);
- F0->Rmin(1) = RminFrom2Points(B0,3,8,F0->GetZ(1));
- F0->Rmin(3) = F0->GetRmin(2)+(ConThick-2.0*ConCthick)*Costc;
- F0->Z(3) = F0->GetZ(2)+(ConThick-2.0*ConCthick)*Sintc;
- F0->Rmax(3) = F0->GetRmin(3);
- printPcon(F0);
- // Holes for Cables to pass Through is created by the intersection
- // between a cone segment and an Arb8, One for the volume A0 and a
- // larger one for the volumes B0 and C0, so that the surface is covered
- // in carbon figer (volume A0).
- TGeoConeSeg *Ah1 = new TGeoConeSeg("ITSssdCableHoleAh1",
- 0.5*ConZLength,ConCableHoleRinner,
- ConCableHoleROut,ConCableHoleRinner,
- ConCableHoleROut,
- 90.-0.5*ConCableHoleWidth/
- ConCableHoleROut/kRadian,
- 90.+0.5*ConCableHoleWidth/
- ConCableHoleROut/kRadian);
- TGeoConeSeg *Bh1 = new TGeoConeSeg("ITSssdCableHoleBh1",0.5*ConZLength,
- ConCableHoleRinner-ConCthick,
- ConCableHoleROut+ConCthick,
- ConCableHoleRinner-ConCthick,
- ConCableHoleROut+ConCthick,
- 90.+((-0.5*ConCableHoleWidth-ConCthick)/
- (ConCableHoleROut-ConCthick))/kRadian,
- 90.+((+0.5*ConCableHoleWidth-ConCthick)/
- (ConCableHoleROut-ConCthick))/kRadian);
- x0 = Ah1->GetRmax1()*TMath::Cos(Ah1->GetPhi2()*kRadian);
- y0 = Ah1->GetRmax1()*TMath::Sin(Ah1->GetPhi2()*kRadian);
- TGeoArb8 *Ah2 = new TGeoArb8("ITSssdCableHoleAh2",0.5*ConZLength);
- y = Ah1->GetRmax1();
- x = x0+(y-y0)/TMath::Tan((90.0+ConCableHoleAngle)*kRadian);
- Ah2->SetVertex(0,x,y);
- y = Ah1->GetRmin1()*TMath::Sin(Ah1->GetPhi2()*kRadian);
- x = x0+(y-y0)/TMath::Tan((90.0+ConCableHoleAngle)*kRadian);
- Ah2->SetVertex(3,x,y);
- x0 = Ah1->GetRmax1()*TMath::Cos(Ah1->GetPhi1()*kRadian);
- y0 = Ah1->GetRmax1()*TMath::Sin(Ah1->GetPhi1()*kRadian);
- y = Ah1->GetRmax1();
- x = x0+(y-y0)/TMath::Tan((90.0-ConCableHoleAngle)*kRadian);
- Ah2->SetVertex(1,x,y);
- y = Ah1->GetRmin1()*TMath::Sin(Ah1->GetPhi1()*kRadian);
- x = x0+(y-y0)/TMath::Tan((90.0-ConCableHoleAngle)*kRadian);
- Ah2->SetVertex(2,x,y);
- //
- x0 = Bh1->GetRmax1()*TMath::Cos(Bh1->GetPhi2()*kRadian);
- y0 = Bh1->GetRmax1()*TMath::Sin(Bh1->GetPhi2()*kRadian);
- TGeoArb8 *Bh2 = new TGeoArb8("ITSssdCableHoleBh2",0.5*ConZLength);
- y = Bh1->GetRmax1();
- x = x0+(y-y0)/TMath::Tan((90.0+ConCableHoleAngle)*kRadian);
- Bh2->SetVertex(0,x,y);
- y = Bh1->GetRmin1()*TMath::Sin(Bh1->GetPhi2()*kRadian);
- x = x0+(y-y0)/TMath::Tan((90.0+ConCableHoleAngle)*kRadian);
- Bh2->SetVertex(3,x,y);
- x0 = Bh1->GetRmax1()*TMath::Cos(Bh1->GetPhi1()*kRadian);
- y0 = Bh1->GetRmax1()*TMath::Sin(Bh1->GetPhi1()*kRadian);
- y = Bh1->GetRmax1();
- x = x0+(y-y0)/TMath::Tan((90.0-ConCableHoleAngle)*kRadian);
- Bh2->SetVertex(1,x,y);
- y = Bh1->GetRmin1()*TMath::Sin(Bh1->GetPhi1()*kRadian);
- x = x0+(y-y0)/TMath::Tan((90.0-ConCableHoleAngle)*kRadian);
- Bh2->SetVertex(2,x,y);
- for(i=0;i<4;i++){ // define points at +dz
- Ah2->SetVertex(i+4,(Ah2->GetVertices())[2*i],
- (Ah2->GetVertices())[1+2*i]);
- Bh2->SetVertex(i+4,(Bh2->GetVertices())[2*i],
- (Bh2->GetVertices())[1+2*i]);
- } // end for i
- TGeoBBox *Ah3 = new TGeoBBox("ITSssdCoolingHoleAh3",0.5*ConCoolHoleWidth,
- 0.5*ConCoolHoleHight,0.5*ConZLength);
- TGeoBBox *Bh3 = new TGeoBBox("ITSssdCoolingHoleBh3",
- 0.5*ConCoolHoleWidth+ConCthick,
- 0.5*ConCoolHoleHight+ConCthick,
- 0.5*ConZLength);
- TGeoBBox *Ah4 = new TGeoBBox("ITSssdMountingPostHoleAh4",
- 0.5*ConMountHoleWidth,
- 0.5*ConMountHoleHight,0.5*ConZLength);
- TGeoBBox *Bh4 = new TGeoBBox("ITSssdMountingPostHoleBh4",
- 0.5*ConMountHoleWidth+ConCthick,
- 0.5*ConMountHoleHight+ConCthick,
- 0.5*ConZLength);
- printConeSeg(Ah1);
- printConeSeg(Bh1);
- printArb8(Ah2);
- printArb8(Bh2);
- printBBox(Ah3);
- printBBox(Bh3);
- printBBox(Ah4);
- printBBox(Bh4);
- // SSD Cone Wings
- TGeoConeSeg *G = new TGeoConeSeg("ITSssdWingCarbonFiberSurfaceG",
- 0.5*ConWingThick,ConROuterMax-ConCthick,
- ConWingRmax,
- ConROuterMax-ConCthick,ConWingRmax,
- ConWingPhi0-0.5*ConWingWidth/ConWingRmax*kRadian,
- ConWingPhi0+0.5*ConWingWidth/ConWingRmax*kRadian);
- TGeoConeSeg *H = new TGeoConeSeg("ITSssdWingStaseliteH",
- 0.5*ConWingThick-ConCthick,ConROuterMax-ConCthick,
- ConWingRmax-ConCthick,
- ConROuterMax-ConCthick,
- ConWingRmax-ConCthick,
- ConWingPhi0-((0.5*ConWingWidth-ConCthick)/
- (ConWingRmax-ConCthick))*kRadian,
- ConWingPhi0+((0.5*ConWingWidth-ConCthick)/
- (ConWingRmax-ConCthick))*kRadian);
- printConeSeg(G);
- printConeSeg(H);
- // SDD support plate, SSD side.
- //Poly-cone Volume T.
- TGeoTubeSeg *T = new TGeoTubeSeg("ITSssdsddMountingBracketT",
- SupPRmin,SupPRmax,
- SupPZ,SupPPhi1,
- SupPPhi2);
- printTubeSeg(T);
- //
- 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] = ConCoolHoleRmin+0.5*ConCoolHoleHight;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] = ConMountHoleRmin+0.5*ConMountHoleHight; vl[1] = 0.0; vl[2] = 0.0;
- rotZ30->LocalToMaster(vl,vg);
- TGeoCombiTrans *rotranA30 = new TGeoCombiTrans("ITSssdConeTZ30",vl[0],
- vl[1],vl[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] = A0->GetZ(10)+T->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();
- TGeoCompositeShape *A = new TGeoCompositeShape(
- "ITSssdSuportConeCarbonFiberSurfaceA","(((((((((((((((((((((((((((("
- "ITSssdSuportConeCarbonFiberSurfaceA0 +"
- "ITSssdWingCarbonFiberSurfaceG) +"
- "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ90) +"
- "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ180) +"
- "ITSssdWingCarbonFiberSurfaceG:ITSssdConeZ270) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ225) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ675) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ1125) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ1575) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ2025) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ2475) -"
- "(ITSssdCableHoleAh1*ITSssdCableHoleAh2):ITSssdConeZ2925) -"
- "(ITSssdCableHoleAh1*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"
- );
- TGeoCompositeShape *B = new TGeoCompositeShape(
- "ITSssdSuportConeStaseliteB","(((((((((((((((((((((((((((("
- "ITSssdSuportConeStaseliteB0 +"
- "ITSssdWingStaseliteH) +"
- "ITSssdWingStaseliteH:ITSssdConeZ90) +"
- "ITSssdWingStaseliteH:ITSssdConeZ180) +"
- "ITSssdWingStaseliteH:ITSssdConeZ270) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ225) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ675) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ1125) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ1575) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ2025) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ2475) -"
- "(ITSssdCableHoleBh1*ITSssdCableHoleBh2):ITSssdConeZ2925) -"
- "(ITSssdCableHoleBh1*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"
- );
- TGeoCompositeShape *C = 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))"
- );
- TGeoCompositeShape *F = 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.
- TGeoTube *D = new TGeoTube("ITS Screw+stud used to mount things to "
- "the SSD support cone",
- 0.0,ConRScrewM5by12,ConLScrewM5by12);
- printTube(D);
- TGeoTube *E = new TGeoTube("ITS pin used to mount things to the "
- "SSD support cone",0.0,ConRPinO6,ConLPinO6);
- printTube(E);
- // Bolt heads holding the SSD-SDD tube to the SSD cone.
- // Bolt -- PolyCone
- //Poly-cone Volume Q.
- TGeoPcon *Q = new TGeoPcon("ITS SSD Thermal sheal M6 screw headQ",
- 0.0,360.0,4);
- Q->Z(0) = A0->GetZ(12);
- Q->Rmin(0) = 0.0;
- Q->Rmax(0) = CylRM6;
- Q->Z(1) = Q->GetZ(0) + ConZM6Head;
- Q->Rmin(1) = 0.0;
- Q->Rmax(1) = CylRM6;
- Q->Z(2) = Q->GetZ(1);
- Q->Rmin(2) = 0.0;
- Q->Rmax(2) = ConRM6Head;
- Q->Z(3) = Q->GetZ(0)-SupPZ;
- Q->Rmin(3) = 0.0;
- Q->Rmax(3) = 0.5*ConRM6Head;
- printPcon(Q);
- // air infront of bolt (stasolit Volume K) -- Tube
- TGeoTube *R = new TGeoTube("ITS Air in front of bolt (in stasolit)R",
- Q->GetRmin(3),Q->GetRmax(3),
- 0.5*(SupPZ-ConCthick));
- // air infront of bolt (carbon fiber volume I) -- Tube
- TGeoTube *S = new TGeoTube("ITS Air in front of Stainless Steal Screw "
- "end, M6S",Q->GetRmin(3),Q->GetRmax(3),
- 0.5*ConCthick);
- printTube(S);
- //
- TGeoVolume *Av,*Bv,*Cv,*Dv,*Ev,*Fv,*Qv,*Rv,*Sv,*Tv;
- //
- Av = new TGeoVolume("ITSssdConeA",A,SSDcf); // Carbon Fiber
- Av->SetVisibility(kTRUE);
- Av->SetLineColor(4); // blue
- Av->SetLineWidth(1);
- Av->SetFillColor(Av->GetLineColor());
- Av->SetFillStyle(4000); // 0% transparent
- Bv = new TGeoVolume("ITSssdConeB",B,SSDfs); // Staselite
- Bv->SetVisibility(kTRUE);
- Bv->SetLineColor(2); // red
- Bv->SetLineWidth(1);
- Bv->SetFillColor(Bv->GetLineColor());
- Bv->SetFillStyle(4010); // 10% transparent
- Cv = new TGeoVolume("ITSssdConeC",C,SSDfo); // Rohacell
- Cv->SetVisibility(kTRUE);
- Cv->SetLineColor(3); // green
- Cv->SetLineWidth(1);
- Cv->SetFillColor(Cv->GetLineColor());
- Cv->SetFillStyle(4050); // 50% transparent
- Fv = new TGeoVolume("ITSssdConeF",F,SSDfo); // Rohacell;
- Fv->SetVisibility(kTRUE);
- Fv->SetLineColor(3); // green
- Fv->SetLineWidth(1);
- Fv->SetFillColor(Fv->GetLineColor());
- Fv->SetFillStyle(4050); // 50% transparent
- Dv = new TGeoVolume("ITSssdConeD",D,SSDss);
- Dv->SetVisibility(kTRUE);
- Dv->SetLineColor(1); // black
- Dv->SetLineWidth(1);
- Dv->SetFillColor(Dv->GetLineColor());
- Dv->SetFillStyle(4000); // 0% transparent
- Ev = new TGeoVolume("ITSssdConeE",E,SSDss);
- Ev->SetVisibility(kTRUE);
- Ev->SetLineColor(1); // black
- Ev->SetLineWidth(1);
- Ev->SetFillColor(Ev->GetLineColor());
- Ev->SetFillStyle(4000); // 0% transparent
- Qv = new TGeoVolume("ITSssdConeQ",Q,SSDss);
- Qv->SetVisibility(kTRUE);
- Qv->SetLineColor(1); // black
- Qv->SetLineWidth(1);
- Qv->SetFillColor(Qv->GetLineColor());
- Qv->SetFillStyle(4000); // 00% transparent
- Rv = new TGeoVolume("ITSssdConeR",R,SSDair);
- Rv->SetVisibility(kTRUE);
- Rv->SetLineColor(5); // yellow
- Rv->SetLineWidth(1);
- Rv->SetFillColor(Rv->GetLineColor());
- Rv->SetFillStyle(4090); // 90% transparent
- Sv = new TGeoVolume("ITSssdConeS",S,SSDair);
- Sv->SetVisibility(kTRUE);
- Sv->SetLineColor(5); // yellow
- Sv->SetLineWidth(1);
- Sv->SetFillColor(Sv->GetLineColor());
- Sv->SetFillStyle(4090); // 90% transparent
- Tv = new TGeoVolume("ITSssdsddMountingBracket",S,SSDal);
- Tv->SetVisibility(kTRUE);
- Tv->SetLineColor(5); // yellow
- Tv->SetLineWidth(1);
- Tv->SetFillColor(Tv->GetLineColor());
- Tv->SetFillStyle(4000); // 0% transparent
- //
- TGeoCombiTrans *rotran;
- TGeoTranslation *tran;
- tran = new TGeoTranslation("ITSssdConeTrans",0.0,0.0,-ConZDisplacement);
- TGeoRotation *rotY180 = new TGeoRotation("",0.0,180.0,0.0);
- TGeoCombiTrans *flip = new TGeoCombiTrans("ITSssdConeFlip",
- 0.0,0.0,ConZDisplacement,rotY180);
- delete rotY180;// rot not explicity used in AddNode functions.
- //
- //
- //
- //
- Av->AddNode(Bv,1,0);
- Bv->AddNode(Cv,1,0);
- Bv->AddNode(Fv,1,0);
- Moth->AddNode(Av,1,tran); // RB24 side
- Moth->AddNode(Av,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,NcopyRv=0,NcopySv=0,NcopyTv=0;
- Int_t NcopyDv=0,NcopyEv=0;
- z = CB->GetZ(0)-0.5*CylZPin;
- dt = (360.0/((Double_t)CylNPin));
- for(i=0;i<CylNPin;i++){
- t = ((Double_t)i)*dt;
- x = CylRholes*TMath::Cos((t+CylPhi0Pin)*kRadian);
- y = CylRholes*TMath::Sin((t+CylPhi0Pin)*kRadian);
- tran = new TGeoTranslation("",x,y,z);
- CBv->AddNode(CDv,++NcopyCDv,tran);
- tran = new TGeoTranslation("",x,y,-z);
- CBv->AddNode(CDv,++NcopyCDv,tran);
- } // end for i
- dt = (360.0/((Double_t)CylNM6));
- for(i=0;i<CylNM6;i++){
- t = ((Double_t)i)*dt;
- x = CylRholes*TMath::Cos((t+CylPhi0M6)*kRadian);
- y = CylRholes*TMath::Sin((t+CylPhi0M6)*kRadian);
- z = CB->GetZ(0)-0.5*CylZM6;
- tran = new TGeoTranslation("",x,y,z);
- CBv->AddNode(CEv,++NcopyCEv,tran);
- tran = new TGeoTranslation("",x,y,-z);
- CBv->AddNode(CEv,++NcopyCEv,tran);
- tran = new TGeoTranslation("",x,y,0.0);
- Bv->AddNode(Qv,++NcopyQv,tran);
- if(!((t<rotranBrTZ60->GetRotation()->GetPhiRotation()+T->GetPhi2()&&
- t>rotranBrTZ60->GetRotation()->GetPhiRotation()-T->GetPhi1())||
- (t<rotranBrTZ180->GetRotation()->GetPhiRotation()+T->GetPhi2()&&
- t>rotranBrTZ180->GetRotation()->GetPhiRotation()-T->GetPhi1())||
- (t<rotranBrTZ300->GetRotation()->GetPhiRotation()+T->GetPhi2()&&
- t>rotranBrTZ300->GetRotation()->GetPhiRotation()-T->GetPhi1()))){
- // If not at an angle where the bracket T is located.
- tran = new TGeoTranslation("",x,y,B0->GetZ(10)-R->GetDz());
- Bv->AddNode(Rv,++NcopyRv,tran);
- tran = new TGeoTranslation("",x,y,A0->GetZ(10)-S->GetDz());
- Av->AddNode(Sv,++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] = A0->GetZ(10)+ConZDisplacement-T->GetDz();
- rotZ60->LocalToMaster(vl,vg);
- rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ60);
- Moth->AddNode(Tv,++NcopyTv,rotran);
- rotZ180->LocalToMaster(vl,vg);
- rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ180);
- Moth->AddNode(Tv,++NcopyTv,rotran);
- rotZ300->LocalToMaster(vl,vg);
- rotran = new TGeoCombiTrans("",vg[0],vg[1],vg[2],rotZ300);
- Moth->AddNode(Tv,++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)*kRadian;
- for(j=-ConNScrewM5by12/2;j<=ConNScrewM5by12/2;j++)if(j!=0){
- //screws per ITS-TPC brkt
- t = t0 + 5.0*((Double_t)j)*kRadian;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Dv,++NcopyDv,tran);
- } // end or j
- for(j=-ConNPinO6/2;j<=ConNPinO6/2;j++){ // pins per ITS-TPC bracket
- t = t0 + 3.0*((Double_t)j)*kRadian;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Ev,++NcopyEv,tran);
- } // end or j
- t0 = (96.5+187.*((Double_t)i))*kRadian;
- for(j=0;j<ConNRailScrews;j++){ // screws per ITS-rail bracket
- t = t0+da[j]*kRadian;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Dv,++NcopyDv,tran);
- } // end or j
- t0 = (91.5+184.*((Double_t)i))*kRadian;
- for(j=-ConNRailPins/2;j<=ConNRailPins/2;j++)if(j!=0){
- // pins per ITS-rail bracket
- t = t0+(7.0*((Double_t)j))*kRadian;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Ev,++NcopyEv,tran);
- } // end or j
- } // end for i
- for(i=0;i<ConNmounts;i++){
- // mounting points for SPD-cone+Beam-pipe support
- t0 = (45.0+((Double_t)i)*360./((Double_t)ConNmounts))*kRadian;
- for(j=-1;j<=1;j++)if(j!=0){ // 2 screws per bracket
- t = t0+((Double_t)j)*0.5*ConMountPhi0*kRadian;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Dv,++NcopyDv,tran);
- } // end for j
- for(j=0;j<1;j++){ // 1 pin per bracket
- t = t0;
- tran = new TGeoTranslation("",ConROutHoles*TMath::Cos(t),
- ConROutHoles*TMath::Sin(t),
- B0->GetZ(0)+D->GetDz());
- Bv->AddNode(Ev,++NcopyEv,tran);
- } // end for j
- } // end for i
- if(GetDebug()){
- Av->PrintNodes();
- Bv->PrintNodes();
- Cv->PrintNodes();
- Dv->PrintNodes();
- Ev->PrintNodes();
- Fv->PrintNodes();
- Qv->PrintNodes();
- Rv->PrintNodes();
- Sv->PrintNodes();
- Tv->PrintNodes();
- } // end if
+void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2, Double_t d,
+ Double_t &x, Double_t &y) const
+{
+//
+// Determines the X and Y of the first internal point of the Omega shape
+// (i.e. the coordinates of a point given two parallel lines passing by
+// two points and placed at a known distance)
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/PointFromParallelLines.gif">
+*/
+//End_Html
+
+ // The slope of the paralles lines at a distance d
+ Double_t m;
+
+ // The parameters of the solving equation
+ // a x^2 - 2 b x + c = 0
+ Double_t a = (x1 - x2)*(x1 - x2) - d*d;
+ Double_t b = (x1 - x2)*(y1 - y2);
+ Double_t c = (y1 - y2)*(y1 - y2) - d*d;
+
+ // (delta4 is Delta/4 because we use the reduced formula)
+ Double_t delta4 = b*b - a*c;
+
+ // Compute the slope of the two parallel lines
+ // (one of the two possible slopes, the one with the smaller
+ // absolute value is needed)
+ if (delta4 < 0) { // Should never happen with our data, but just to be sure
+ x = -1; // x is expected positive, so this flags an error
+ return;
+ } else
+ m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data
+
+ // Finally compute the coordinates of the point
+ x = x2 + (y1 - y2 - d)/m;
+ y = y1 - d;
+
+ // Done
+ return;
}
//______________________________________________________________________
-void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *Moth){
- // Define the detail ITS cable support trays on both the RB24 and
- // RB26 sides..
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- // Based on the Drawings SSup_201A.jpg unless otherwise stated,
- // Volumes A...,
- TGeoMedium *SUPcf = 0; // SUP support cone Carbon Fiber materal number.
- TGeoMedium *SUPfs = 0; // SUP support cone inserto stesalite 4411w.
- TGeoMedium *SUPfo = 0; // SUP support cone foam, Rohacell 50A.
- TGeoMedium *SUPss = 0; // SUP support cone screw material,Stainless
- TGeoMedium *SUPair = 0; // SUP support cone Air
- TGeoMedium *SUPal = 0; // SUP support cone SDD mounting bracket Al
- TGeoMedium *SUPwater = 0; // SUP support cone Water
- TGeoManager *mgr = gGeoManager;
- SUPcf = mgr->GetMedium("ITSssdCarbonFiber");
- SUPfs = mgr->GetMedium("ITSssdStaselite4411w");
- SUPfo = mgr->GetMedium("ITSssdRohacell50A");
- SUPss = mgr->GetMedium("ITSssdStainlessSteal");
- SUPair = mgr->GetMedium("ITSssdAir");
- SUPal = mgr->GetMedium("ITSssdAl");
- SUPwater = mgr->GetMedium("ITSssdWater");
- //
- Int_t i,j;
- Double_t x,y,z,t,t0,dt,di,r;
-
- // RB 24 side
- const Double_t Z024 = 900*kmm;//SSup_203A.jpg
- const Double_t ThssFrame24 = 5.0*kmm;
- const Double_t RssFrame24 = 444.5*kmm-ThssFrame24; // SSup_204A.jpg
- const Double_t WidthFrame24 = 10.0*kmm;
- const Double_t HightFrame24 = 10.0*kmm;
- const Double_t Phi0Frame24 = 15.2*kDegree; // SSup_602A.jpg
- const Double_t Phi1Frame24 = (90.0-7.6)*kDegree; // SSup_802A.jpg
- const Double_t ZssFrameSection24 = (415.0-10.0)*kmm;
- const Int_t NZsections24 = 4;
- const Int_t NPhiSections24 = 4;
- const Int_t NFramesPhi24 = 4;
- //
- TGeoTubeSeg *M24 = new TGeoTubeSeg("ITS sup Cable tray support frame "
- "mother volume M24",
- RssFrame24,RssFrame24+ThssFrame24,
- 0.5*(4.*ZssFrameSection24+5*WidthFrame24),
- Phi0Frame24,Phi1Frame24);
- TGeoTubeSeg *A24 = new TGeoTubeSeg("ITS sup Cable tray support frame "
- "radial section A24",
- RssFrame24,RssFrame24+ThssFrame24,0.5*WidthFrame24,
- Phi0Frame24,Phi1Frame24);
- TGeoBBox *B24 = new TGeoBBox("ITS sup Cable tray support frame Z section "
- "B24",
- 0.5*ThssFrame24,0.5*HightFrame24,0.5*ZssFrameSection24);
- printTubeSeg(A24);
- printTubeSeg(M24);
- printBBox(B24);
- TGeoVolume *A24v,*B24v,*M24v;
- TGeoTranslation *tran;
- TGeoRotation *rot;
- TGeoCombiTrans *tranrot;
- //
- A24v = new TGeoVolume("ITSsupFrameA24",A24,SUPss);
- A24v->SetVisibility(kTRUE);
- A24v->SetLineColor(1); // black
- A24v->SetLineWidth(1);
- A24v->SetFillColor(A24v->GetLineColor());
- A24v->SetFillStyle(4000); // 0% transparent
- B24v = new TGeoVolume("ITSsupFrameB24",B24,SUPss);
- B24v->SetVisibility(kTRUE);
- B24v->SetLineColor(1); // black
- B24v->SetLineWidth(1);
- B24v->SetFillColor(B24v->GetLineColor());
- B24v->SetFillStyle(4000); // 0% transparent
- M24v = new TGeoVolume("ITSsupFrameM24",M24,SUPair);
- M24v->SetVisibility(kTRUE);
- M24v->SetLineColor(7); // light blue
- M24v->SetLineWidth(1);
- M24v->SetFillColor(M24v->GetLineColor());
- M24v->SetFillStyle(4090); // 90% transparent
- //
- Int_t NcA24=1,NcB24=1;
- t0 = Phi0Frame24;
- dt = (Phi1Frame24-Phi0Frame24)/((Double_t)NPhiSections24);
- for(i=0;i<=NZsections24;i++){
- di = (Double_t) i;
- z = -M24->GetDz()+A24->GetDz() + di*(ZssFrameSection24+WidthFrame24);
- tran = new TGeoTranslation("",0.0,0.0,z);
- M24v->AddNode(A24v,NcA24++,tran);
- r = RssFrame24+B24->GetDX();
- z = z + A24->GetDz()+B24->GetDZ();
- if(i<NZsections24) for(j=0;j<=NPhiSections24;j++){
- t = t0 + ((Double_t)j)*dt;
- rot = new TGeoRotation("",0.0,0.0,t);
- y = r*TMath::Sin(t*kRadian);
- x = r*TMath::Cos(t*kRadian);
- tranrot = new TGeoCombiTrans("",x,y,z,rot);
- delete rot;// rot not explicity used in AddNode functions.
- M24v->AddNode(B24v,NcB24++,tranrot);
- } // end for j
- } // end for i
- tran = new TGeoTranslation("",0.0,0.0,Z024+M24->GetDz());
- Moth->AddNode(M24v,1,tran);
- for(i=1;i<NFramesPhi24;i++){
- di = (Double_t) i;
- rot = new TGeoRotation("",0.0,0.0,90.0*di);
- tranrot = new TGeoCombiTrans("",0.0,0.0,Z024+M24->GetDz(),rot);
- delete rot;// rot not explicity used in AddNode functions.
- Moth->AddNode(M24v,i+1,tranrot);
- } // end for i
- if(GetDebug()){
- A24v->PrintNodes();
- B24v->PrintNodes();
- M24v->PrintNodes();
- } // end if
- // Cable support tray
- // Material is Aluminum
- //const Double_t RS24in = TMath::Max(RssFrame24,444.5*kmm);
- // SSup_204A & SSup_206A
- //const Double_t RS24Airout = 459.5*kmm; // SSup_204A & SSup_206A
- //const Double_t RS24out = 494.5*kmm; // SSup_206A & SSup_204A
- //const Double_t RS24PPout = 550.0*kmm; // SSup_206A
- const Double_t LS24PP = 350.0*kmm; // SSup_202A
- const Double_t LS24 = (2693.0-900.0)*kmm; //SSup_205A & SSup_207A
- const Double_t ThS24wall = 1.0*kmm; // SSup_209A & SSup_210A
- const Double_t WbS24 = 42.0*kmm; // SSup_209A & SSup_210A
- //const Double_t WtS24 = 46.9*kmm; // SSup_209A & SSup_210A
- const Double_t WcapS24 = 50.0*kmm; // SSup_209A & SSup_210A
- //const Double_t WdS24 = 41.0*kmm; //SSup_209A ? should be 41.46938776
- const Double_t HS24 = 50.0*kmm; // SSup_209A & SSup_210A
- const Double_t OutDcoolTub= 12.0*kmm; // SSup_209A
- const Double_t InDcoolTub = 10.0*kmm; // SSup_209A
- const Double_t BlkNozInDS24= 6.0*kmm; // SSup_209A
- // The following are deduced or guessed at
- //const Double_t LtopLipS24 = 6.0*kmm; // Guessed at.
- //const Double_t LdLipS24 = 6.0*kmm; // Guessed at.
- //const Double_t HdS24 = OutDcoolTub; //
- const Double_t BlkNozZS24 = 6.0*kmm; // Guessed at.
- // Simplifided exterior shape. The side wall size is 2.5*thicker than
- // it should be (due to simplification).
- TGeoArb8 *C24 = new TGeoArb8("ITS Sup Cable Tray Element C24",0.5*LS24);
- C24->SetVertex(0,-0.5*WcapS24,HS24+ThS24wall);
- C24->SetVertex(1,+0.5*WcapS24,HS24+ThS24wall);
- C24->SetVertex(2,+0.5*WbS24,0.0);
- C24->SetVertex(3,-0.5*WbS24,0.0);
- C24->SetVertex(4,-0.5*WcapS24,HS24+ThS24wall);
- C24->SetVertex(5,+0.5*WcapS24,HS24+ThS24wall);
- C24->SetVertex(6,+0.5*WbS24,0.0);
- C24->SetVertex(7,-0.5*WbS24,0.0);
- TGeoArb8 *D24 = new TGeoArb8("ITS Sup Cable Tray lower Element D24",
- 0.5*LS24);
- // Because of question about the value of WdS24, compute what it
- // should be assuming cooling tube fixes hight of volume.
- x = OutDcoolTub*(0.5*WcapS24-0.5*WbS24-ThS24wall)/(HS24-ThS24wall);
- D24->SetVertex(0,-x,OutDcoolTub+ThS24wall);
- D24->SetVertex(1,+x,OutDcoolTub+ThS24wall);
- D24->SetVertex(2,+0.5*WbS24-ThS24wall,ThS24wall);
- D24->SetVertex(3,-0.5*WbS24+ThS24wall,ThS24wall);
- D24->SetVertex(4,-x,OutDcoolTub+ThS24wall);
- D24->SetVertex(5,+x,OutDcoolTub+ThS24wall);
- D24->SetVertex(6,+0.5*WbS24-ThS24wall,ThS24wall);
- D24->SetVertex(7,-0.5*WbS24+ThS24wall,ThS24wall);
- TGeoTube *E24 = new TGeoTube("ITS Sup Cooling Tube E24",0.5*InDcoolTub,
- 0.5*OutDcoolTub,0.5*LS24-BlkNozZS24);
- TGeoArb8 *F24 = new TGeoArb8("ITS Sup Cable Tray lower Element block F24",
- 0.5*BlkNozZS24);
- for(i=0;i<8;i++) F24->SetVertex(i,D24->GetVertices()[i*2+0],
- D24->GetVertices()[i*2+1]); //
- TGeoTube *G24 = new TGeoTube("ITS Sup Cooling Tube hole in block G24",
- 0.0,0.5*BlkNozInDS24,0.5*BlkNozZS24);
- TGeoArb8 *H24 = new TGeoArb8("ITS Sup Cable Tray upper Element H24",
- 0.5*(LS24- LS24PP));
- H24->SetVertex(0,C24->GetVertices()[0*2+0]+2.*ThS24wall,
- C24->GetVertices()[0*2+1]-ThS24wall);
- H24->SetVertex(1,C24->GetVertices()[1*2+0]-2.*ThS24wall,
- C24->GetVertices()[1*2+1]-ThS24wall);
- H24->SetVertex(2,D24->GetVertices()[1*2+0]-ThS24wall,
- D24->GetVertices()[1*2+1]+ThS24wall);
- H24->SetVertex(3,D24->GetVertices()[0*2+0]+ThS24wall,
- D24->GetVertices()[0*2+1]+ThS24wall);
- for(i=4;i<8;i++) H24->SetVertex(i,H24->GetVertices()[(i-4)*2+0],
- H24->GetVertices()[(i-4)*2+1]); //
- printArb8(C24);
- printArb8(D24);
- printTube(E24);
- printArb8(F24);
- printTube(G24);
- printArb8(H24);
- TGeoVolume *C24v,*D24v,*E24v,*F24v,*Ga24v,*Gw24v,*H24v;
- //
- C24v = new TGeoVolume("ITSsupCableTrayC24",C24,SUPal);
- C24v->SetVisibility(kTRUE);
- C24v->SetLineColor(6); //
- C24v->SetLineWidth(1);
- C24v->SetFillColor(C24v->GetLineColor());
- C24v->SetFillStyle(4000); // 0% transparent
- D24v = new TGeoVolume("ITSsupCableTrayLowerD24",D24,SUPair);
- D24v->SetVisibility(kTRUE);
- D24v->SetLineColor(6); //
- D24v->SetLineWidth(1);
- D24v->SetFillColor(D24v->GetLineColor());
- D24v->SetFillStyle(4000); // 0% transparent
- E24v = new TGeoVolume("ITSsupCableTrayCoolTubeE24",E24,SUPss);
- E24v->SetVisibility(kTRUE);
- E24v->SetLineColor(6); //
- E24v->SetLineWidth(1);
- E24v->SetFillColor(E24v->GetLineColor());
- E24v->SetFillStyle(4000); // 0% transparent
- F24v = new TGeoVolume("ITSsupCableTrayBlockF24",F24,SUPal);
- F24v->SetVisibility(kTRUE);
- F24v->SetLineColor(6); //
- F24v->SetLineWidth(1);
- F24v->SetFillColor(F24v->GetLineColor());
- F24v->SetFillStyle(4000); // 0% transparent
- Gw24v = new TGeoVolume("ITSsupCableTrayCoolantWaterG24",G24,SUPwater);
- Gw24v->SetVisibility(kTRUE);
- Gw24v->SetLineColor(6); //
- Gw24v->SetLineWidth(1);
- Gw24v->SetFillColor(Gw24v->GetLineColor());
- Gw24v->SetFillStyle(4000); // 0% transparent
- Ga24v = new TGeoVolume("ITSsupCableTrayCoolantAirG24",G24,SUPair);
- Ga24v->SetVisibility(kTRUE);
- Ga24v->SetLineColor(6); //
- Ga24v->SetLineWidth(1);
- Ga24v->SetFillColor(Ga24v->GetLineColor());
- Ga24v->SetFillStyle(4000); // 0% transparent
- H24v = new TGeoVolume("ITSsupCableTrayUpperC24",H24,SUPair);
- H24v->SetVisibility(kTRUE);
- H24v->SetLineColor(6); //
- H24v->SetLineWidth(1);
- H24v->SetFillColor(H24v->GetLineColor());
- H24v->SetFillStyle(4000); // 0% transparent
- //
- tran = new TGeoTranslation("",-OutDcoolTub,OutDcoolTub+ThS24wall,0.0);
- F24v->AddNode(Gw24v,1,tran);
- D24v->AddNode(E24v,1,tran);
- tran = new TGeoTranslation("",0.0,OutDcoolTub+ThS24wall,0.0);
- F24v->AddNode(Gw24v,2,tran);
- D24v->AddNode(E24v,2,tran);
- tran = new TGeoTranslation("",+OutDcoolTub,OutDcoolTub+ThS24wall,0.0);
- F24v->AddNode(Gw24v,3,tran);
- D24v->AddNode(E24v,3,tran);
- tran = new TGeoTranslation("",0.0,0.0,0.5*LS24-0.5*BlkNozZS24);
- D24v->AddNode(F24v,1,tran);
- tran = new TGeoTranslation("",0.0,0.0,-(0.5*LS24-0.5*BlkNozZS24));
- D24v->AddNode(F24v,2,tran);
- C24v->AddNode(D24v,1,0);
- C24v->AddNode(H24v,1,0);
- //==================================================================
- //
- // RB 26 side
- const Double_t Z026 = -900*kmm;//SSup_203A.jpg
- const Double_t ThssFrame26 = 5.0*kmm;
- const Double_t R0ssFrame26 = 444.5*kmm-ThssFrame26; // SSup_204A.jpg
- const Double_t R1ssFrame26 = 601.6*kmm-ThssFrame26; // SSup_208A.jpg
- const Double_t WidthFrame26 = 10.0*kmm;
- //const Double_t HightFrame26 = 10.0*kmm;
- const Double_t Phi0Frame26 = 15.2*kDegree; // SSup_602A.jpg
- const Double_t Phi1Frame26 = (90.0-7.6)*kDegree; // SSup_802A.jpg
- const Double_t ZssFrameSection26 = (415.0-10.0)*kmm;
- const Int_t NZsections26 = 4;
- const Int_t NPhiSections26 = 4;
- const Int_t NFramesPhi26 = 4;
- TGeoConeSeg *A26[NZsections26+1],*M26; // Cylinderial support structure
- TGeoArb8 *B26; // Cylinderial support structure
- Char_t name[100];
- Double_t r1,r2,m;
-
- M26 = new TGeoConeSeg("ITS sup Cable tray support frame mother volume "
- "M26",0.5*(4.*ZssFrameSection26+5*WidthFrame26),
- R1ssFrame26,R1ssFrame26+ThssFrame26,
- R0ssFrame26,R0ssFrame26+ThssFrame26,
- Phi0Frame26,Phi1Frame26);
- m = -((R1ssFrame26-R0ssFrame26)/
- (((Double_t)NZsections26)*(ZssFrameSection26+WidthFrame26)));
- for(i=0;i<NZsections26+1;i++){
- di = ((Double_t) i)*(ZssFrameSection26+WidthFrame26);
- sprintf(name,
- "ITS sup Cable tray support frame radial section A26[%d]",i);
- r1 = R1ssFrame26+m*di;
- r2 = R1ssFrame26+m*(di+WidthFrame26);
- A26[i] = new TGeoConeSeg(name,0.5*WidthFrame26,r2,r2+ThssFrame26,
- r1,r1+ThssFrame26,Phi0Frame26,Phi1Frame26);
- } // end for i
- B26 = new TGeoArb8("ITS sup Cable tray support frame Z section B26",
- 0.5*ZssFrameSection26);
- r = 0.25*(A26[0]->GetRmax1()+A26[0]->GetRmin1()+
- A26[1]->GetRmax2()+A26[1]->GetRmin2());
- B26->SetVertex(0,A26[0]->GetRmax2()-r,+0.5*WidthFrame26);
- B26->SetVertex(1,A26[0]->GetRmax2()-r,-0.5*WidthFrame26);
- B26->SetVertex(2,A26[0]->GetRmin2()-r,-0.5*WidthFrame26);
- B26->SetVertex(3,A26[0]->GetRmin2()-r,+0.5*WidthFrame26);
- B26->SetVertex(4,A26[1]->GetRmax1()-r,+0.5*WidthFrame26);
- B26->SetVertex(5,A26[1]->GetRmax1()-r,-0.5*WidthFrame26);
- B26->SetVertex(6,A26[1]->GetRmin1()-r,-0.5*WidthFrame26);
- B26->SetVertex(7,A26[1]->GetRmin1()-r,+0.5*WidthFrame26);
- for(i=0;i<NZsections26+1;i++) printConeSeg(A26[i]);
- printConeSeg(M26);
- printArb8(B26);
- TGeoVolume *A26v[NZsections26+1],*B26v,*M26v;
- //
- for(i=0;i<NZsections26+1;i++){
- sprintf(name,"ITSsupFrameA26[%d]",i);
- A26v[i] = new TGeoVolume(name,A26[i],SUPss);
- A26v[i]->SetVisibility(kTRUE);
- A26v[i]->SetLineColor(1); // black
- A26v[i]->SetLineWidth(1);
- A26v[i]->SetFillColor(A26v[i]->GetLineColor());
- A26v[i]->SetFillStyle(4000); // 0% transparent
- } // end for i
- B26v = new TGeoVolume("ITSsupFrameB26",B26,SUPss);
- B26v->SetVisibility(kTRUE);
- B26v->SetLineColor(1); // black
- B26v->SetLineWidth(1);
- B26v->SetFillColor(B26v->GetLineColor());
- B26v->SetFillStyle(4000); // 0% transparent
- M26v = new TGeoVolume("ITSsupFrameM26",M26,SUPair);
- M26v->SetVisibility(kTRUE);
- M26v->SetLineColor(7); // light blue
- M26v->SetLineWidth(1);
- M26v->SetFillColor(M26v->GetLineColor());
- M26v->SetFillStyle(4090); // 90% transparent
- //
- Int_t NcB26=1;
- t0 = Phi0Frame26;
- dt = (Phi1Frame26-Phi0Frame26)/((Double_t)NPhiSections26);
- for(i=0;i<=NZsections26;i++){
- di = ((Double_t) i)*(ZssFrameSection26+WidthFrame26);
- z = -M26->GetDz()+A26[i]->GetDz() + di;
- tran = new TGeoTranslation("",0.0,0.0,z);
- M26v->AddNode(A26v[i],1,tran);
- z = z+B26->GetDz();
- if(i<NZsections26)for(j=0;j<=NPhiSections26;j++){
- r = 0.25*(A26[i]->GetRmax1()+A26[i]->GetRmin1()+
- A26[i+1]->GetRmax2()+A26[i+1]->GetRmin2());
- t = t0 + ((Double_t)j)*dt;
- rot = new TGeoRotation("",0.0,0.0,t);
- y = r*TMath::Sin(t*kRadian);
- x = r*TMath::Cos(t*kRadian);
- tranrot = new TGeoCombiTrans("",x,y,z,rot);
- delete rot; // rot not explicity used in AddNode functions.
- M26v->AddNode(B26v,NcB26++,tranrot);
- } // end for j
- } // end for i
- tran = new TGeoTranslation("",0.0,0.0,Z026-M26->GetDz());
- Moth->AddNode(M26v,1,tran);
- for(i=1;i<NFramesPhi26;i++){
- rot = new TGeoRotation("",0.0,0.0,90.0*((Double_t)i));
- tranrot = new TGeoCombiTrans(*tran,*rot);
- delete rot; // rot not explicity used in AddNode functions.
- Moth->AddNode(M26v,i+1,tranrot);
- } // end for i
- if(GetDebug()){
- for(i=0;i<NZsections26+1;i++) A26v[i]->PrintNodes();
- B26v->PrintNodes();
- M26v->PrintNodes();
- } // end if
+void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2,
+ Double_t x3, Double_t y3,
+ Double_t &x, Double_t &y) const
+{
+//
+// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
+// lying on the line parallel to the line passing by these points,
+// at a distance d and passing by the point (x3,y3), which is symmetric to
+// the third point with respect to the axis of the segment delimited by
+// the two first points.
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// x3, y3 : third point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the reflected point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/ReflectPoint.gif">
+*/
+//End_Html
+
+ // The slope of the line passing by the first two points
+ Double_t k = (y2 - y1)/(x2 - x1);
+
+ // The middle point of the segment 1-2
+ Double_t xK = (x1 + x2)/2.;
+ Double_t yK = (y1 + y2)/2.;
+
+ // The intercept between the axis of the segment 1-2 and the line
+ // passing by 3 and parallel to the line passing by 1-2
+ Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
+ Double_t yH = k*(xH - x3) + y3;
+
+ // The point symmetric to 3 with respect to H
+ x = 2*xH - x3;
+ y = 2*yH - y3;
+
+ // Done
+ return;
}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
+{
+//
+// Creates the SDD support cone and cylinder geometry as a
+// 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; i<kNBolts; i++){
+ t = kThetaBolt*i;
+ x = kBoltRadius*CosD(t);
+ y = kBoltRadius*SinD(t);
+ z = kFlangeHalfLength-kBoltDepth;
+ flangecylinder->AddNode(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; i<kNHole3; i++) {
+ Double_t phiH0 = 360./(Double_t)kNHole3;
+ Double_t phiH = i*phiH0 + 0.5*phiH0;
+ cfconefoam->AddNode(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; i<kNHole4; i++) {
+ Double_t phiH0 = 360./(Double_t)kNHole4;
+ Double_t phiH = i*phiH0 + 0.25*phiH0;
+ cfcone->AddNode(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,const 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 = (1143.6/2) *fgkmm;
+ const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm;
+ const Double_t kCylinderThickness = 0.625*fgkmm;
+ const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
+ 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
+ /*
+ <img src="picts/ITS/file_name.gif">
+ <P>
+ <FONT FACE'"TIMES">
+ ITS SSD central support and thermal shield cylinder.
+ </FONT>
+ </P>
+ */
+ //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,
+ const TGeoManager *mgr){
+//
+// Creates the structure supporting the ITS cable trays on Side A
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 14 Dec 2009 Mario Sitta
+// Updated: 26 Feb 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the A-Side Cable Tray Support Ring
+ // (0872/G/A/01)
+ const Double_t kSuppRingYTrans = 110.00 *fgkmm;
+ const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm;
+ const Double_t kSuppForwYTrans = 185.00 *fgkmm;
+
+ const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm;
+ const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm;
+ const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm;
+ const Double_t kExtSuppRingBase = 491.50 *fgkmm;
+ const Double_t kExtSuppRingInward = 35.00 *fgkmm;
+ const Double_t kExtSuppRingRmax = 540.00 *fgkmm;
+ const Double_t kExtSuppRingRint1 = 465.00 *fgkmm;
+ const Double_t kExtSuppRingRint2 = 467.00 *fgkmm;
+ const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm;
+ const Double_t kExtSuppRingInWide = 100.00 *fgkmm;
+ const Double_t kExtSuppRingR7 = 7.00 *fgkmm;
+ const Double_t kExtSuppRingR5 = 5.00 *fgkmm;
+ const Double_t kExtSuppRingThick = 20.00 *fgkmm;
+
+ const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad();
+ const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad();
+ const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed
+
+ const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc
+
+ const Double_t kIntSuppRingThick1 = 15.00 *fgkmm;
+ const Double_t kIntSuppRingThick2 = 13.00 *fgkmm;
+ const Double_t kIntSuppRingInward = 24.00 *fgkmm;
+ const Double_t kIntSuppRingThick = 20.00 *fgkmm;
+
+ const Double_t kSuppCylHeight = 340.00 *fgkmm;
+ const Double_t kSuppCylRint = 475.00 *fgkmm;
+ const Double_t kSuppCylRext = 478.00 *fgkmm;
+ const Double_t kSuppCylDispl = 137.70 *fgkmm;
+
+ const Double_t kSuppSpacerHeight = 30.00 *fgkmm;
+ const Double_t kSuppSpacerThick = 10.00 *fgkmm;
+
+ const Double_t kSuppSpacerAngle = 15.00; // Degrees
+
+ const Double_t kSuppForwRingRint1 = 500.00 *fgkmm;
+ const Double_t kSuppForwRingRint2 = 540.00 *fgkmm;
+ const Double_t kSuppForwRingRext = 560.00 *fgkmm;
+ const Double_t kSuppForwRingThikAll = 50.00 *fgkmm;
+ const Double_t kSuppForwRingThikInt = 20.00 *fgkmm;
+
+ // (0872/G/B/01)
+ const Double_t kSuppForwConeRmin = 558.00 *fgkmm;
+ const Double_t kSuppForwConeRmax = 681.00 *fgkmm;
+ const Double_t kSuppForwConeLen1 = 318.00 *fgkmm;
+ const Double_t kSuppForwConeLen2 = 662.00 *fgkmm;
+ const Double_t kSuppForwConeThick = 3.00 *fgkmm;
+
+ const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm;
+ const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm;
+ const Double_t kSuppBackRingHeight = 760.00 *fgkmm;
+ const Double_t kSuppBackRingRext = 760.00 *fgkmm;
+ const Double_t kSuppBackRingRint = 685.00 *fgkmm;
+// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm;
+ const Double_t kSuppBackRingR10 = 10.00 *fgkmm;
+ const Double_t kSuppBackRingBase = 739.00 *fgkmm;
+ const Double_t kSuppBackRingThikAll = 50.00 *fgkmm;
+ const Double_t kSuppBackRingThick1 = 20.00 *fgkmm;
+ const Double_t kSuppBackRingThick2 = 20.00 *fgkmm;
+
+// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad();
+ const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp.
+ const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad();
+ const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad();
+
+ const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc
+
+ // (0872/G/C/01)
+ const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm;
+ const Double_t kBackRodZTrans = 2420.00 *fgkmm;
+
+ const Double_t kBackRodLength = 1160.00 *fgkmm;
+ const Double_t kBackRodThickLen = 20.00 *fgkmm;
+ const Double_t kBackRodDiameter = 20.00 *fgkmm;
+
+ const Double_t kSuppRearRingRint = 360.00 *fgkmm;
+ const Double_t kSuppRearRingRext1 = 410.00 *fgkmm;
+ const Double_t kSuppRearRingRext2 = 414.00 *fgkmm;
+ const Double_t kSuppRearRingHeight = 397.00 *fgkmm;
+ const Double_t kSuppRearRingTopWide = 111.87 *fgkmm;
+ const Double_t kSuppRearRingBase = 451.50 *fgkmm;
+ const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm;
+ const Double_t kSuppRearRingSideHi = 52.00 *fgkmm;
+ const Double_t kSuppRearRingInside = 40.00 *fgkmm;
+ const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm;
+ const Double_t kSuppRearRingThick = 20.00 *fgkmm;
+ const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm;
+ const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm;
+
+ const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad();
+ const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad();
+
+ const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc
+
+
+ // Local variables
+ Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
+ Double_t slp1, slp2, phi, xm, ym;
+ Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
+ Int_t npoints;
+
+
+ // The whole support as an assembly
+ TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
+
+
+ // First create all needed shapes
+
+ // The External Ring (part of 0872/G/A/01): a really complex Xtru
+ TGeoXtru *extSuppRing = new TGeoXtru(2);
+
+ // First the upper notch...
+ xprof[ 0] = kExtSuppRingSpace1;
+ yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
+
+ slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
+ IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
+ xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
+
+ xprof[ 4] = xprof[5];
+ yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
+ xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
+ yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6));
+ xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
+ yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3));
+ xprof[ 1] = xprof[4] - kExtSuppRingR5;
+ yprof[ 1] = yprof[4] - kExtSuppRingR5;
+
+ Int_t indx = 5+kExtSuppRingNPtsArc;
+ // ...then the external arc, approximated with segments,...
+ xprof[indx] = kExtSuppRingBase;
+ yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
+ kExtSuppRingBase*kExtSuppRingBase);
+ Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
+ Double_t alphamax = TMath::Pi()/2 -
+ TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
+
+ for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
+ Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
+ xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
+ yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
+ }
+ // ...and finally the interior profile
+ xprof[indx+1] = kExtSuppRingBase;
+ yprof[indx+1] = kSuppRingYTrans;
+ xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
+ yprof[indx+2] = yprof[indx+1];
+
+ phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
+ slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint2*TMath::Cos(phi);
+ ym = kExtSuppRingRint2*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
+ xprof[indx+3], yprof[indx+3]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint1*TMath::Cos(phi);
+ ym = kExtSuppRingRint1*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
+ xprof[indx+4], yprof[indx+4]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint2*TMath::Cos(phi);
+ ym = kExtSuppRingRint2*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
+ xprof[indx+5], yprof[indx+5]);
+
+ slp1 = slp2;
+ phi += kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = kExtSuppRingRint1*TMath::Cos(phi);
+ ym = kExtSuppRingRint1*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
+ xprof[indx+6], yprof[indx+6]);
+
+ xprof[indx+9] = kExtSuppRingInWide;
+ yprof[indx+9] = kExtSuppRingInnerHi;
+ xprof[indx+8] = xprof[indx+9] +
+ (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
+ yprof[indx+8] = yprof[indx+9] +
+ ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
+ xprof[indx+7] = xprof[indx+9] +
+ (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7;
+ yprof[indx+7] = yprof[indx+9] +
+ ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7;
+ // Gosh, we did the right side! now reflex on the left side
+ npoints = (sizeof(xprof)/sizeof(Double_t))/2;
+ for (Int_t jp = 0; jp < npoints; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-1-jp];
+ yprof[npoints+jp] = yprof[npoints-1-jp];
+ }
+ // wow! now the actual Xtru
+ extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
+ extSuppRing->DefineSection(0,0);
+ extSuppRing->DefineSection(1,kExtSuppRingThick);
+
+ // The Internal Ring (part of 0872/G/A/01): another complex Xtru
+ TGeoXtru *intSuppRing = new TGeoXtru(2);
+
+ // First the external profile...
+ npoints = 0;
+
+ slp1 = 0;
+ phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
+ IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi -= kExtSuppRingPartPhi;
+ slp2 = TMath::Tan(TMath::Pi()/2 + phi);
+ xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
+ ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
+ yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
+ xprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = xprof[npoints-1];
+ yprof[npoints] = kSuppRingYTrans;
+ npoints++;
+ // ...and then the interior profile, which is identical to extSuppRing one
+ for (Int_t jp=0; jp < 8; jp++) {
+ xprof[npoints] = extSuppRing->GetX(17+jp);
+ yprof[npoints] = extSuppRing->GetY(17+jp);
+ npoints++;
+ }
+ // We did the right side! now reflex on the left side
+ for (Int_t jp = 0; jp < npoints; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-1-jp];
+ yprof[npoints+jp] = yprof[npoints-1-jp];
+ }
+ // And now the actual Xtru
+ intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
+ intSuppRing->DefineSection(0,0);
+ intSuppRing->DefineSection(1,kIntSuppRingThick);
+
+ // The intermediate cylinder (0872/G/A/03): a TubeSeg
+ alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+ TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
+ kSuppCylHeight/2, alphamin, alphamax);
+
+ // The spacer (0872/G/A/03): a simple Xtru
+ TGeoXtru *suppSpacer = new TGeoXtru(2);
+
+ xprof[0] = kSuppSpacerHeight;
+ yprof[0] = kSuppSpacerThick;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = 0;
+ yprof[2] = 0;
+ xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
+ yprof[3] = yprof[0];
+
+ suppSpacer->DefinePolygon(4, xprof, yprof);
+ suppSpacer->DefineSection(0,-kSuppCylHeight/2);
+ suppSpacer->DefineSection(1, kSuppCylHeight/2);
+
+ // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
+ Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
+ alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+
+ TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
+
+ forwardRing->DefineSection(0,0,
+ kSuppForwRingRint1,kSuppForwRingRext);
+ forwardRing->DefineSection(1,kSuppForwRingThikInt,
+ kSuppForwRingRint1,kSuppForwRingRext);
+ forwardRing->DefineSection(2,kSuppForwRingThikInt,
+ kSuppForwRingRint2,kSuppForwRingRext);
+ forwardRing->DefineSection(3,kSuppForwRingThikAll,
+ kSuppForwRingRint2,kSuppForwRingRext);
+
+ // The forward cone (0872/G/B/03): a TGeoPcon
+ TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
+
+ forwardCone->DefineSection(0,0,
+ kSuppForwConeRmin-kSuppForwConeThick,
+ kSuppForwConeRmin);
+ forwardCone->DefineSection(1,kSuppForwConeLen1,
+ kSuppForwConeRmin-kSuppForwConeThick,
+ kSuppForwConeRmin);
+ forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
+ kSuppForwConeRmax-kSuppForwConeThick,
+ kSuppForwConeRmax);
+
+ // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
+ TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
+
+ // First the external profile... (the arc is approximated with segments)
+ npoints = 0;
+
+ xprof[npoints] = kSuppBackRingPlacTop;
+ yprof[npoints] = kSuppBackRingHeight;
+ npoints++;
+
+ alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
+ alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
+
+ xprof[npoints] = xprof[npoints-1];
+ yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
+ npoints++;
+
+ for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
+ Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
+ xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
+ yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
+ npoints++;
+ }
+
+ xprof[npoints] = kSuppBackRingBase -
+ kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
+ yprof[npoints] = yprof[npoints-1];
+ npoints++;
+
+ xprof[npoints] = kSuppBackRingBase;
+ yprof[npoints] = kSuppForwYTrans;
+ npoints++;
+ // ...then the internal profile (the arc is approximated with segments)
+ alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
+ alphamax = TMath::Pi()/2;
+
+ for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
+ Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
+ xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
+ yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
+ npoints++;
+ }
+
+ xprof[npoints] = 0;
+ yprof[npoints] = kSuppBackRingRint;
+ npoints++;
+ // We did the right side! now reflex on the left side (except last point)
+ for (Int_t jp = 0; jp < npoints-1; jp++) {
+ xprof[npoints+jp] = -xprof[npoints-jp-2];
+ yprof[npoints+jp] = yprof[npoints-jp-2];
+ }
+ // And now the actual Xtru
+ firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
+ firstSuppBackRing->DefineSection(0,0);
+ firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
+
+ // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
+ // (slight oversimplification)
+ alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
+ alphamax = 180 - alphamin;
+
+ TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
+
+ deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
+ rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
+ rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
+ rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
+ rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
+
+ slp1 = TMath::Tan(kSuppBackRing2ndAng2);
+ slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
+ IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
+ slp2,kSuppBackRingThikAll,deltaR,
+ xm, ym);
+
+ zloc = xm - kSuppBackRingThick1;
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR;
+ secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
+
+ zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
+ rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
+ rmax = rmin + deltaR/2;
+ secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
+
+ // The supporting rod: a Tube
+ TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
+ (kBackRodLength - kBackRodThickLen)/2);
+
+ // The Back Ring (0872/G/C/01): another complex Xtru
+ TGeoXtru *suppRearRing = new TGeoXtru(2);
+
+ // First the external profile...
+ npoints = 0;
+
+ xprof[npoints] = kSuppRearRingTopWide;
+ yprof[npoints] = kSuppRearRingHeight;
+ npoints++;
+
+ phi = kSuppRearRing1stAng;
+ slp1 = TMath::Tan(TMath::Pi() - phi);
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext2*TMath::Sin(phi);
+ ym = kSuppRearRingRext2*TMath::Cos(phi);
+ IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext1*TMath::Sin(phi);
+ ym = kSuppRearRingRext1*TMath::Cos(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ phi += kSuppRearRingStepAng;
+ slp2 = TMath::Tan(TMath::Pi() - phi);
+ xm = kSuppRearRingRext2*TMath::Sin(phi);
+ ym = kSuppRearRingRext2*TMath::Cos(phi);
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ slp1 = slp2;
+ slp2 = 0;
+ xm = kSuppRearRingBase;
+ ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
+ IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
+ slp2, xm, ym,
+ xprof[npoints], yprof[npoints]);
+ npoints++;
+
+ xprof[npoints] = kSuppRearRingBase;
+ yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1];
+ yprof[npoints] = kSuppRearRingBaseHi;
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
+ yprof[npoints] = yprof[npoints - 1];
+ npoints++;
+ xprof[npoints] = xprof[npoints - 1];
+ yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
+ npoints++;
+ // ...then the internal arc, approximated with segments,...
+ xprof[npoints] = kSuppRearRingRint;
+ yprof[npoints] = yprof[npoints - 1];
+
+ alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
+ alphamax = TMath::Pi()/2;
+
+ for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
+ Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
+ xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
+ yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
+ }
+
+ xprof[npoints+kSuppRearRingNPtsArc] = 0;
+ yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
+ // We did the right side! now reflex on the left side
+ Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
+ for (Int_t jp = 0; jp < nTotalPoints; jp++) {
+ xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
+ yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp];
+ }
+
+ // And now the actual Xtru
+ suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
+ suppRearRing->DefineSection(0,0);
+ suppRearRing->DefineSection(1,kSuppRearRingThick);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
+
+ TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
+ extSuppRing, medAl);
+
+ sideAExtSuppRing->SetVisibility(kTRUE);
+ sideAExtSuppRing->SetLineColor(kMagenta+1);
+ sideAExtSuppRing->SetLineWidth(1);
+ sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
+ sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
+ intSuppRing, medAl);
+
+ sideAIntSuppRing->SetVisibility(kTRUE);
+ sideAIntSuppRing->SetLineColor(kMagenta+1);
+ sideAIntSuppRing->SetLineWidth(1);
+ sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
+ sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
+ interCylind, medAl);
+
+ sideASuppCyl->SetVisibility(kTRUE);
+ sideASuppCyl->SetLineColor(kMagenta+1);
+ sideASuppCyl->SetLineWidth(1);
+ sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
+ sideASuppCyl->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
+ suppSpacer, medAl);
+
+ sideASuppSpacer->SetVisibility(kTRUE);
+ sideASuppSpacer->SetLineColor(kMagenta+1);
+ sideASuppSpacer->SetLineWidth(1);
+ sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
+ sideASuppSpacer->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
+ forwardRing, medAl);
+
+ sideASuppForwRing->SetVisibility(kTRUE);
+ sideASuppForwRing->SetLineColor(kMagenta+1);
+ sideASuppForwRing->SetLineWidth(1);
+ sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
+ sideASuppForwRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
+ forwardCone, medAl);
+
+ sideASuppForwCone->SetVisibility(kTRUE);
+ sideASuppForwCone->SetLineColor(kMagenta+1);
+ sideASuppForwCone->SetLineWidth(1);
+ sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
+ sideASuppForwCone->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
+ firstSuppBackRing, medAl);
+
+ sideAFirstSuppBackRing->SetVisibility(kTRUE);
+ sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
+ sideAFirstSuppBackRing->SetLineWidth(1);
+ sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
+ sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
+ secondSuppBackRing, medAl);
+
+ sideASecondSuppBackRing->SetVisibility(kTRUE);
+ sideASecondSuppBackRing->SetLineColor(kMagenta+1);
+ sideASecondSuppBackRing->SetLineWidth(1);
+ sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
+ sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
+ suppRod, medAl);
+
+ sideASuppRod->SetVisibility(kTRUE);
+ sideASuppRod->SetLineColor(kMagenta+1);
+ sideASuppRod->SetLineWidth(1);
+ sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
+ sideASuppRod->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
+ suppRearRing, medAl);
+
+ sideASuppRearRing->SetVisibility(kTRUE);
+ sideASuppRearRing->SetLineColor(kMagenta+1);
+ sideASuppRearRing->SetLineWidth(1);
+ sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
+ sideASuppRearRing->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the support structure
+ zloc = kSuppRingZTrans;
+ trayASuppStruct->AddNode(sideAExtSuppRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAExtSuppRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kExtSuppRingThick;
+ trayASuppStruct->AddNode(sideAIntSuppRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAIntSuppRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ xloc = kExtSuppRingBase - kIntSuppRingInward;
+ yloc = kSuppRingYTrans;
+ zloc += (kIntSuppRingThick + kSuppCylHeight/2);
+ trayASuppStruct->AddNode(sideASuppCyl, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppCyl, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 2,
+ new TGeoCombiTrans(-xloc, yloc, zloc,
+ new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 3,
+ new TGeoCombiTrans( xloc,-yloc, zloc,
+ new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
+ trayASuppStruct->AddNode(sideASuppSpacer, 4,
+ new TGeoCombiTrans(-xloc,-yloc, zloc,
+ new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
+
+
+ zloc += kSuppCylHeight/2;
+ trayASuppStruct->AddNode(sideAIntSuppRing, 3,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAIntSuppRing, 4,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kIntSuppRingThick;
+ trayASuppStruct->AddNode(sideAExtSuppRing, 3,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAExtSuppRing, 4,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kExtSuppRingThick;
+ trayASuppStruct->AddNode(sideASuppForwRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppForwRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kSuppForwRingThikAll;
+ trayASuppStruct->AddNode(sideASuppForwCone, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppForwCone, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
+ trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ zloc += kSuppBackRingThick1;
+ trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
+ new TGeoTranslation(0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+ xloc = kSuppRearRingXRodHole;
+ yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
+ zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
+ trayASuppStruct->AddNode(sideASuppRod, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 3,
+ new TGeoTranslation( xloc,-yloc, zloc) );
+ trayASuppStruct->AddNode(sideASuppRod, 4,
+ new TGeoTranslation(-xloc,-yloc, zloc) );
+
+ zloc += suppRod->GetDz();
+ trayASuppStruct->AddNode(sideASuppRearRing, 1,
+ new TGeoTranslation( 0, 0, zloc) );
+ trayASuppStruct->AddNode(sideASuppRearRing, 2,
+ new TGeoCombiTrans( 0, 0, zloc,
+ new TGeoRotation("",180,0,0)));
+
+
+ // Finally put everything in the mother volume
+ moth->AddNode(trayASuppStruct,1,0);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the all SPD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 15 Nov 2009 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ SPDCableTraysSideA(moth, mgr);
+ SPDCableTraysSideC(moth, mgr);
+
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the all SDD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 14 Dec 2009 Mario Sitta
+//
+
+ SDDCableTraysSideA(moth, mgr);
+ SDDCableTraysSideC(moth, mgr);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
+ TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC
+// In order to avoid a huge monolithic routine, this method actually
+// calls inner methods to create and assemble the various (macro)pieces
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 15 Nov 2009 Mario Sitta
+//
+
+ SSDCableTraysSideA(moth, mgr);
+ SSDCableTraysSideC(moth, mgr);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SPD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: 15 Feb 2010 Mario Sitta
+// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello and D.Elia
+// (small differences with blueprints - e.g. -0.07mm in R1Trans and
+// R2Trans - fix small overlaps; they are then compensated in positioning
+// the Rear Tray to avoid its own overlaps with the rear supporting ring)
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
+//
+
+ // Overall position and rotation of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayAR1Trans = 396.93 *fgkmm;
+ const Double_t kTrayAR2Trans = 413.93 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
+ const Double_t kForwardTrayFirstLen = 435.00 *fgkmm;
+ const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+
+ const Int_t kForwardSideNpoints = 6;
+
+ const Double_t kExternalTrayLen = 1200.00 *fgkmm;
+ const Double_t kExternalTrayWide = kForwardTrayWide;
+ const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
+ const Double_t kExternalTrayThick = kForwardTrayThick;
+
+ const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
+
+ const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
+ const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
+ const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
+ const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024*fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695*fgkmm;// Computed
+
+ const Double_t kTrayCCablesRot = 75.000*fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 227.000*fgkmm;// Computed
+
+
+ // Local variables
+ Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
+ Double_t xloc, yloc, zloc, alpharot;
+
+
+ // The two tray components as assemblies
+ TGeoVolumeAssembly *cableTrayAForw =
+ new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
+ TGeoVolumeAssembly *cableTrayAExt =
+ new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
+
+
+ // First create all needed shapes
+
+ // The lower face of the forward tray: a BBox
+ TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ kForwardTrayTotalLen/2);
+
+ // The side face of the forward tray: a Xtru
+ TGeoXtru *forwTraySideFace = new TGeoXtru(2);
+ forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
+
+ xprof[0] = 0;
+ yprof[0] = kForwardTrayThick;
+ xprof[1] = kForwardTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
+ xprof[3] = kForwardTrayFirstLen;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ forwTraySideFace->DefinePolygon(6, xprof, yprof);
+ forwTraySideFace->DefineSection(0, 0);
+ forwTraySideFace->DefineSection(1, kForwardTrayThick);
+
+ // The covers of the forward tray: two BBox's
+ TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ kForwardTrayFirstLen/2);
+
+ TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
+ kForwardTrayThick/2,
+ (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
+
+ // Each small wing of the forward tray: a BBox
+ TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
+ (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
+ kForwardTrayThick/2);
+
+ // The internal plane of the forward tray: a BBox
+ TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
+ kForwardTrayThick/2,
+ kForwardTrayTotalLen/2);
+
+ // The internal wall of the forward tray: a BBox
+ TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
+ (kForwardTrayInterSpace-kForwardTrayThick)/2,
+ kForwardTrayTotalLen/2);
+
+ // Each horizontal face of the external tray: a BBox
+ TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
+ kExternalTrayThick/2,
+ kExternalTrayLen/2);
+
+ // Each vertical face of the external tray: a BBox
+ TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
+ kExternalTrayHigh/2,
+ kExternalTrayLen/2);
+
+ // The internal wall of the external tray: a BBox
+ TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
+ (kForwardTrayInterSpace-kExternalTrayThick)/2,
+ kExternalTrayLen/2);
+
+ // The cooling tube inside the forward tray: a Tube
+ Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
+ - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
+ Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
+ TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
+
+ // The freon inside the forward tray tubes: a Tube
+ TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
+
+ // The cooling tube inside the external tray: a Ctub
+ TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
+ kExternalTrayLen/2, 0, 360,
+ 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
+ 0, 0, 1);
+
+ // The freon inside the forward tray tubes: a Tube
+ TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
+ kExternalTrayLen/2, 0, 360,
+ 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
+ 0, 0, 1);
+
+ // The optical fibers inside the forward tray: a Xtru
+ TGeoXtru *optFibsForw = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kOpticalFibersSect;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kOpticalFibersSect;
+
+ optFibsForw->DefinePolygon(6, xprof, yprof);
+ optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
+ optFibsForw->DefineSection(1, kOpticalFibersSect/2);
+
+ // The optical fibers inside the external tray: a Xtru
+ TGeoXtru *optFibsExt = new TGeoXtru(2);
+ optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kOpticalFibersSect;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ optFibsExt->DefinePolygon(4, xprof, yprof);
+ optFibsExt->DefineSection(0, 0);
+ optFibsExt->DefineSection(1, kOpticalFibersSect);
+
+ // The Low Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *lowCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;
+
+ lowCablesForwCu->DefinePolygon(6, xprof, yprof);
+ lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);
+
+ TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);
+
+ xprof[0] = lowCablesForwCu->GetX(5);
+ yprof[0] = lowCablesForwCu->GetY(5);
+ xprof[1] = lowCablesForwCu->GetX(4);
+ yprof[1] = lowCablesForwCu->GetY(4);
+ xprof[2] = lowCablesForwCu->GetX(3);
+ yprof[2] = lowCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;
+
+ lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
+ lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);
+
+ // The Low Voltage inside the external tray: two Xtru
+ TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
+ lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ lowCablesExtCu->DefinePolygon(4, xprof, yprof);
+ lowCablesExtCu->DefineSection(0, 0);
+ lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
+
+ TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
+ lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
+
+ xprof[0] = lowCablesExtCu->GetX(3);
+ yprof[0] = lowCablesExtCu->GetY(3);
+ xprof[1] = lowCablesExtCu->GetX(2);
+ yprof[1] = lowCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ lowCablesExtPUR->DefineSection(0, 0);
+ lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
+
+ // The High Voltage cables inside the forward tray: two Xtru
+ TGeoXtru *hiCablesForwCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;
+
+ hiCablesForwCu->DefinePolygon(6, xprof, yprof);
+ hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);
+
+ TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesForwCu->GetX(5);
+ yprof[0] = hiCablesForwCu->GetY(5);
+ xprof[1] = hiCablesForwCu->GetX(4);
+ yprof[1] = hiCablesForwCu->GetY(4);
+ xprof[2] = hiCablesForwCu->GetX(3);
+ yprof[2] = hiCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;
+
+ hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
+ hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
+ hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);
+
+ // The High Voltage inside the external tray: two Xtru
+ TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
+ hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ hiCablesExtCu->DefinePolygon(4, xprof, yprof);
+ hiCablesExtCu->DefineSection(0, 0);
+ hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
+ hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
+
+ xprof[0] = hiCablesExtCu->GetX(3);
+ yprof[0] = hiCablesExtCu->GetY(3);
+ xprof[1] = hiCablesExtCu->GetX(2);
+ yprof[1] = hiCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
+ hiCablesExtPUR->DefineSection(0, 0);
+ hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
+
+ // The Coaxial cables inside the forward tray: two Xtru
+ TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
+ coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
+ xprof[1] = 0;
+ yprof[1] = 0;
+ xprof[2] = kForwardTrayTotalLen;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableSectCu/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableSectCu/2;
+
+ coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
+ coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");
+
+ xprof[0] = coaxCablesForwCu->GetX(5);
+ yprof[0] = coaxCablesForwCu->GetY(5);
+ xprof[1] = coaxCablesForwCu->GetX(4);
+ yprof[1] = coaxCablesForwCu->GetY(4);
+ xprof[2] = coaxCablesForwCu->GetX(3);
+ yprof[2] = coaxCablesForwCu->GetY(3);
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
+ xprof[4] = xprof[1];
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoaxCableHighMeg/2;
+
+ coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
+ coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
+ coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);
+
+ // The Coaxial inside the external tray: two Xtru
+ TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
+ coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
+
+ yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
+ + 2*forwTrayWall->GetDY();
+ xprof[0] = yprof[0]*TanD(kTrayAZRot);
+ xprof[1] = kExternalTrayLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoaxCableSectCu/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtCu->DefineSection(0, 0);
+ coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
+
+ TGeoXtru *coaxCablesExtMeg = new TGeoXtru(2);
+ coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");
+
+ xprof[0] = coaxCablesExtCu->GetX(3);
+ yprof[0] = coaxCablesExtCu->GetY(3);
+ xprof[1] = coaxCablesExtCu->GetX(2);
+ yprof[1] = coaxCablesExtCu->GetY(2);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoaxCableHighMeg/2;
+ yprof[3] = yprof[2];
+ xprof[3] = yprof[2]*TanD(kTrayAZRot);
+
+ coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
+ coaxCablesExtMeg->DefineSection(0, 0);
+ coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
+ TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
+
+ TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
+ forwTrayLowerFace, medAl);
+
+ forwTrayABase->SetVisibility(kTRUE);
+ forwTrayABase->SetLineColor(6); // Purple
+ forwTrayABase->SetLineWidth(1);
+ forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
+ forwTrayABase->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
+ forwTraySideFace, medAl);
+
+ forwTrayASide->SetVisibility(kTRUE);
+ forwTrayASide->SetLineColor(6); // Purple
+ forwTrayASide->SetLineWidth(1);
+ forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
+ forwTrayASide->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
+ forwTrayShortCover, medAl);
+
+ forwTrayACoverShort->SetVisibility(kTRUE);
+ forwTrayACoverShort->SetLineColor(6); // Purple
+ forwTrayACoverShort->SetLineWidth(1);
+ forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
+ forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
+ forwTrayLongCover, medAl);
+
+ forwTrayACoverLong->SetVisibility(kTRUE);
+ forwTrayACoverLong->SetLineColor(6); // Purple
+ forwTrayACoverLong->SetLineWidth(1);
+ forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
+ forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
+ forwTrayWing, medAl);
+
+ forwTrayAWing->SetVisibility(kTRUE);
+ forwTrayAWing->SetLineColor(6); // Purple
+ forwTrayAWing->SetLineWidth(1);
+ forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
+ forwTrayAWing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
+ forwTrayPlane, medAl);
+
+ forwTrayAPlane->SetVisibility(kTRUE);
+ forwTrayAPlane->SetLineColor(6); // Purple
+ forwTrayAPlane->SetLineWidth(1);
+ forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
+ forwTrayAPlane->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
+ forwTrayWall, medAl);
+
+ forwTrayAWall->SetVisibility(kTRUE);
+ forwTrayAWall->SetLineColor(6); // Purple
+ forwTrayAWall->SetLineWidth(1);
+ forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
+ forwTrayAWall->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
+ extTrayHorFace, medAl);
+
+ extTrayAHorFace->SetVisibility(kTRUE);
+ extTrayAHorFace->SetLineColor(6); // Purple
+ extTrayAHorFace->SetLineWidth(1);
+ extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
+ extTrayAHorFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
+ extTrayVerFace, medAl);
+
+ extTrayAVerFace->SetVisibility(kTRUE);
+ extTrayAVerFace->SetLineColor(6); // Purple
+ extTrayAVerFace->SetLineWidth(1);
+ extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
+ extTrayAVerFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
+ extTrayWall, medAl);
+
+ extTrayAWall->SetVisibility(kTRUE);
+ extTrayAWall->SetLineColor(6); // Purple
+ extTrayAWall->SetLineWidth(1);
+ extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
+ extTrayAWall->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
+ coolTubeForw, medIn);
+
+ forwCoolTube->SetVisibility(kTRUE);
+ forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
+ forwCoolTube->SetLineWidth(1);
+ forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
+ forwCoolTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
+ freonTubeForw, medFreon);
+
+ forwCoolFreon->SetVisibility(kTRUE);
+ forwCoolFreon->SetLineColor(kBlue); // Blue
+ forwCoolFreon->SetLineWidth(1);
+ forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
+ forwCoolFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
+ coolTubeExt, medIn);
+
+ extCoolTube->SetVisibility(kTRUE);
+ extCoolTube->SetLineColor(kGray); // as in GeometrySPD
+ extCoolTube->SetLineWidth(1);
+ extCoolTube->SetFillColor(extCoolTube->GetLineColor());
+ extCoolTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
+ freonTubeExt, medFreon);
+
+ extCoolFreon->SetVisibility(kTRUE);
+ extCoolFreon->SetLineColor(kBlue); // Blue
+ extCoolFreon->SetLineWidth(1);
+ extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
+ extCoolFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
+ optFibsForw, medFibs);
+
+ forwOptFibs->SetVisibility(kTRUE);
+ forwOptFibs->SetLineColor(kOrange); // Orange
+ forwOptFibs->SetLineWidth(1);
+ forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
+ forwOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
+ optFibsExt, medFibs);
+
+ extOptFibs->SetVisibility(kTRUE);
+ extOptFibs->SetLineColor(kOrange); // Orange
+ extOptFibs->SetLineWidth(1);
+ extOptFibs->SetFillColor(extOptFibs->GetLineColor());
+ extOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
+ lowCablesForwCu, medCu);
+
+ forwLowCabsCu->SetVisibility(kTRUE);
+ forwLowCabsCu->SetLineColor(kRed); // Red
+ forwLowCabsCu->SetLineWidth(1);
+ forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
+ forwLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
+ lowCablesForwPUR, medPUR);
+
+ forwLowCabsPUR->SetVisibility(kTRUE);
+ forwLowCabsPUR->SetLineColor(kBlack); // Black
+ forwLowCabsPUR->SetLineWidth(1);
+ forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
+ forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
+ lowCablesExtCu, medCu);
+
+ extLowCabsCu->SetVisibility(kTRUE);
+ extLowCabsCu->SetLineColor(kRed); // Red
+ extLowCabsCu->SetLineWidth(1);
+ extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
+ extLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
+ lowCablesExtPUR, medPUR);
+
+ extLowCabsPUR->SetVisibility(kTRUE);
+ extLowCabsPUR->SetLineColor(kBlack); // Black
+ extLowCabsPUR->SetLineWidth(1);
+ extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
+ extLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
+ hiCablesForwCu, medCu);
+
+ forwHiCabsCu->SetVisibility(kTRUE);
+ forwHiCabsCu->SetLineColor(kRed); // Red
+ forwHiCabsCu->SetLineWidth(1);
+ forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
+ forwHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
+ hiCablesForwPUR, medPUR);
+
+ forwHiCabsPUR->SetVisibility(kTRUE);
+ forwHiCabsPUR->SetLineColor(kBlack); // Black
+ forwHiCabsPUR->SetLineWidth(1);
+ forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
+ forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
+ hiCablesExtCu, medCu);
+
+ extHiCabsCu->SetVisibility(kTRUE);
+ extHiCabsCu->SetLineColor(kRed); // Red
+ extHiCabsCu->SetLineWidth(1);
+ extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
+ extHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
+ hiCablesExtPUR, medPUR);
+
+ extHiCabsPUR->SetVisibility(kTRUE);
+ extHiCabsPUR->SetLineColor(kBlack); // Black
+ extHiCabsPUR->SetLineWidth(1);
+ extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
+ extHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
+ coaxCablesForwCu, medCu);
+
+ forwCoaxCu->SetVisibility(kTRUE);
+ forwCoaxCu->SetLineColor(kRed); // Red
+ forwCoaxCu->SetLineWidth(1);
+ forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
+ forwCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
+ coaxCablesForwMeg, medMeg);
+
+ forwCoaxMeg->SetVisibility(kTRUE);
+ forwCoaxMeg->SetLineColor(kBlack); // Black
+ forwCoaxMeg->SetLineWidth(1);
+ forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
+ forwCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
+ coaxCablesExtCu, medCu);
+
+ extCoaxCu->SetVisibility(kTRUE);
+ extCoaxCu->SetLineColor(kRed); // Red
+ extCoaxCu->SetLineWidth(1);
+ extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
+ extCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
+ coaxCablesExtMeg, medMeg);
+
+ extCoaxMeg->SetVisibility(kTRUE);
+ extCoaxMeg->SetLineColor(kBlack); // Black
+ extCoaxMeg->SetLineWidth(1);
+ extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
+ extCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the trays
+ yloc = forwTrayLowerFace->GetDY();
+ zloc = forwTrayLowerFace->GetDZ();
+ cableTrayAForw->AddNode(forwTrayABase, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = kForwardTrayWide/2;
+ cableTrayAForw->AddNode(forwTrayASide, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAForw->AddNode(forwTrayASide, 2,
+ new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
+ zloc = forwTrayShortCover->GetDZ();
+ cableTrayAForw->AddNode(forwTrayACoverShort, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
+ zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
+ cableTrayAForw->AddNode(forwTrayACoverLong, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
+ yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
+ zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc));
+ cableTrayAForw->AddNode(forwTrayAWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc));
+
+ yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
+ zloc = forwTrayPlane->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAPlane, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ yloc = kForwardTrayThick + forwTrayWall->GetDY();
+ zloc = forwTrayWall->GetDZ();
+ cableTrayAForw->AddNode(forwTrayAWall, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ forwCoolTube->AddNode(forwCoolFreon, 1, 0);
+
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
+ + coolTubeForw->GetRmax();
+ zloc = coolTubeForw->GetDz();
+ cableTrayAForw->AddNode(forwCoolTube, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwOptFibs, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwLowCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*lowCablesForwCu->GetZ(1) +
+ hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwHiCabsCu, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
+ coolTubeForw->GetRmax();
+ yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
+ cableTrayAForw->AddNode(forwCoaxCu, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+ cableTrayAForw->AddNode(forwCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,90.,90.)));
+
+ // To simplify following placement in MARS, origin is on top
+ yloc = -kExternalTrayHigh + kExternalTrayThick/2;
+ zloc = kExternalTrayLen/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 1,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
+ yloc = -kExternalTrayHigh/2;
+ cableTrayAExt->AddNode(extTrayAVerFace, 1,
+ new TGeoTranslation( xloc, yloc, zloc));
+ cableTrayAExt->AddNode(extTrayAVerFace, 2,
+ new TGeoTranslation(-xloc, yloc, zloc));
+
+ yloc = -kExternalTrayThick/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 2,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ yloc = -kExternalTrayHigh
+ + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
+ cableTrayAExt->AddNode(extTrayAHorFace, 3,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
+ cableTrayAExt->AddNode(extTrayAWall, 1,
+ new TGeoTranslation( 0, yloc, zloc));
+
+ extCoolTube->AddNode(extCoolFreon, 1, 0);
+
+ yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
+ + coolTubeExt->GetRmax();
+ zloc = coolTubeExt->GetDz();
+ cableTrayAExt->AddNode(extCoolTube, 1,
+ new TGeoTranslation(0, yloc, zloc));
+
+ xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extOptFibs, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extLowCabsCu, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extLowCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extHiCabsCu, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extHiCabsPUR, 1,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
+ coolTubeExt->GetRmax();
+ cableTrayAExt->AddNode(extCoaxCu, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ cableTrayAExt->AddNode(extCoaxMeg, 1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+
+ // Finally put everything in the mother volume
+ Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
+
+ moth->AddNode(cableTrayAForw,1,
+ new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
+ moth->AddNode(cableTrayAForw,2,
+ new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans,
+ new TGeoRotation("",180, 0, 0)));
+
+ yloc = kTrayAR1Trans + kExternalTrayHigh;
+ zloc = kTrayAZTrans + kForwardTrayTotalLen;
+ moth->AddNode(cableTrayAExt,1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0)));
+ moth->AddNode(cableTrayAExt,2,
+ new TGeoCombiTrans( 0,-yloc, zloc,
+ new TGeoRotation("",180,-kTrayAZRot, 0)));
+
+ alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,3,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,4,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,5,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,5,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,6,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,6,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,7,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,7,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,8,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,8,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,9,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,9,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayAR2Trans*SinD(alpharot);
+ yloc = kTrayAR2Trans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,10,
+ new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,10,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SPD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Return:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 22 Apr 2010 Mario Sitta
+// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
+// Updated: 08 Sep 2010 Mario Sitta
+// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
+// Updated: 20 Dec 2011 Mario Sitta Composite vol to avoid new overlap
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by D.Elia
+// Optical fibers and voltage cables are approximated with mean materials
+// and square cross sections, but preserving the total material budget.
+//
+
+ // Dimensions and positions of the C-Side Cable Tray elements
+ const Int_t kNumTraysSideC = 10;
+
+ const Double_t kTrayCCablesOutRot = 75.000 *fgkDegree;// Computed
+ const Double_t kTrayCCablesZLenOut = 245.000 *fgkmm;// Computed
+
+ const Double_t kTrayCHalfWide = 6.350 *fgkcm;
+ const Double_t kTrayCLength1 = 172.800 *fgkcm;
+ const Double_t kTrayCLength2 = 189.300 *fgkcm;
+ const Double_t kTrayCFirstLen = 435.000 *fgkmm;
+ const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCThick = 0.200 *fgkcm;
+ const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
+
+ const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
+ const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
+ const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
+ const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
+ const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
+ const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
+ const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
+ const Double_t kCoaxCableSectCu = 6.024 *fgkmm;// Computed
+ const Double_t kCoaxCableHighMeg = 5.695 *fgkmm;// Computed
+
+ const Double_t kCablesYtrans = 2.500 *fgkmm;// Avoid ovlps
+
+ // Overall position and rotation of the C-Side Cable Trays
+ const Double_t kTraySideCRPos = 45.300 *fgkcm;
+ const Double_t kTraySideCZPos = -102.400 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] =
+ { 0.0, 41.0, -41.0, 76.0, -76.0};
+ // From position of the other trays
+
+
+ // Local variables
+ Double_t xprof[8], yprof[8];
+ Double_t xloc, yloc, zloc, delta, alpharot;
+
+
+ // The single C-Side Cable tray as an assembly
+ TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");
+
+ // First create all needed shapes
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCHorFace = new TGeoXtru(2);
+ sideCHorFace->SetName("ITSsuppSPDTraySideCHor");
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCHorFace->DefinePolygon(6, xprof, yprof);
+ sideCHorFace->DefineSection(0,-delta);
+ sideCHorFace->DefineSection(1, delta);
+
+ // The Cable Tray middle face: a Xtru
+ // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
+ TGeoXtru *sideCMidFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = kTrayCInterSpace + kTrayCThick;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = yprof[0] + kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCMidFace->DefinePolygon(6, xprof, yprof);
+ sideCMidFace->DefineSection(0,-delta);
+ sideCMidFace->DefineSection(1, delta);
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCSideFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kTrayCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
+ yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
+ xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
+ yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kTrayCSecondHigh , xprof[4], yprof[4]);
+ xprof[5] = kTrayCFirstLen;
+ yprof[5] = kTrayCSecondHigh;
+ xprof[6] = xprof[5];
+ yprof[6] = kTrayCFirstHigh;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ sideCSideFace->DefinePolygon(8, xprof, yprof);
+ sideCSideFace->DefineSection(0, 0);
+ sideCSideFace->DefineSection(1, kTrayCThick);
+
+ // The short cover: a BBox
+ TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
+ kTrayCThick/2,
+ kTrayCHalfWide-kTrayCThick);
+
+ // The long cover: a Xtru
+ TGeoXtru *sideCLongCover = new TGeoXtru(2);
+
+ xprof[5] = sideCSideFace->GetX(5);
+ yprof[5] = sideCSideFace->GetY(5);
+ xprof[4] = sideCSideFace->GetX(4);
+ yprof[4] = sideCSideFace->GetY(4);
+ xprof[3] = sideCSideFace->GetX(3);
+ yprof[3] = sideCSideFace->GetY(3);
+ xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
+ yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
+ -kTrayCThick , xprof[1], yprof[1]);
+ xprof[0] = xprof[5];
+ yprof[0] = yprof[5] - kTrayCThick;
+
+ delta = kTrayCHalfWide - kTrayCThick;
+
+ sideCLongCover->DefinePolygon(6, xprof, yprof);
+ sideCLongCover->DefineSection(0,-delta);
+ sideCLongCover->DefineSection(1, delta);
+
+ // The internal wall: a Xtru
+ TGeoXtru *intWall = new TGeoXtru(2);
+ intWall->SetName("ITSsuppSPDTraySideCWall");
+
+ xprof[0] = sideCHorFace->GetX(5);
+ yprof[0] = sideCHorFace->GetY(5);
+ xprof[1] = sideCHorFace->GetX(4);
+ yprof[1] = sideCHorFace->GetY(4);
+ xprof[2] = sideCHorFace->GetX(3);
+ yprof[2] = sideCHorFace->GetY(3);
+ xprof[3] = sideCMidFace->GetX(2);
+ yprof[3] = sideCMidFace->GetY(2);
+ xprof[4] = sideCMidFace->GetX(1);
+ yprof[4] = sideCMidFace->GetY(1);
+ xprof[5] = sideCMidFace->GetX(0);
+ yprof[5] = sideCMidFace->GetY(0);
+
+ intWall->DefinePolygon(6, xprof, yprof);
+ intWall->DefineSection(0,-kTrayCThick/2);
+ intWall->DefineSection(1, kTrayCThick/2);
+
+ // The horizontal part of the cooling tube inside the tray: a Tube
+ delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
+ TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
+
+ // The freon inside the horizontal part of the cooling tube: a Tube
+ TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
+
+ // The inclined part of the cooling tube inside the tray: a Ctub
+ Double_t x3, y3, x4, y4;
+ x3 = sideCMidFace->GetX(3);
+ y3 = sideCMidFace->GetY(3);
+ x4 = sideCMidFace->GetX(4);
+ y4 = sideCMidFace->GetY(4);
+ delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
+ (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) +
+ (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
+ (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
+
+ TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
+ 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
+ 0, 0, 1);
+
+ // The freon inside the inclined part of the cooling tube: a Ctub
+ TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
+ 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
+ 0, 0, 1);
+
+ // The part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
+ 0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
+ // The freon inside the part of the cooling tube outside the tray: a Ctub
+ TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
+ outTube->GetDz(),
+ 0, 360,
+ 0, 0, -1,
+ 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
+
+ // The optical fibers inside the tray: a Xtru
+ TGeoXtru *optFibs = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kOpticalFibersSect , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kOpticalFibersSect;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kOpticalFibersSect;
+
+ optFibs->DefinePolygon(8, xprof, yprof);
+ optFibs->DefineSection(0, 0);
+ optFibs->DefineSection(1, kOpticalFibersSect);
+
+ // The low voltage cables inside the tray: two Xtru
+ TGeoXtru *lowCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableSectCu;
+
+ lowCablesCu->DefinePolygon(8, xprof, yprof);
+ lowCablesCu->DefineSection(0, 0);
+ lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
+
+ TGeoXtru *lowCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = lowCablesCu->GetX(7);
+ yprof[0] = lowCablesCu->GetY(7);
+ xprof[1] = lowCablesCu->GetX(6);
+ yprof[1] = lowCablesCu->GetY(6);
+ xprof[2] = lowCablesCu->GetX(5);
+ yprof[2] = lowCablesCu->GetY(5);
+ xprof[3] = lowCablesCu->GetX(4);
+ yprof[3] = lowCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kLowVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kLowVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kLowVoltCableHighPUR;
+
+ lowCablesPUR->DefinePolygon(8, xprof, yprof);
+ lowCablesPUR->DefineSection(0, 0);
+ lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
+
+ // The high voltage cables inside the tray: two Xtru
+ TGeoXtru *hiCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableSectCu;
+
+ hiCablesCu->DefinePolygon(8, xprof, yprof);
+ hiCablesCu->DefineSection(0, 0);
+ hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
+
+ TGeoXtru *hiCablesPUR = new TGeoXtru(2);
+
+ xprof[0] = hiCablesCu->GetX(7);
+ yprof[0] = hiCablesCu->GetY(7);
+ xprof[1] = hiCablesCu->GetX(6);
+ yprof[1] = hiCablesCu->GetY(6);
+ xprof[2] = hiCablesCu->GetX(5);
+ yprof[2] = hiCablesCu->GetY(5);
+ xprof[3] = hiCablesCu->GetX(4);
+ yprof[3] = hiCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kHiVoltCableHighPUR , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kHiVoltCableHighPUR;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kHiVoltCableHighPUR;
+
+ hiCablesPUR->DefinePolygon(8, xprof, yprof);
+ hiCablesPUR->DefineSection(0, 0);
+ hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
+
+ // The coaxial cables inside the tray: two Xtru
+ TGeoXtru *coaxCablesCu = new TGeoXtru(2);
+
+ xprof[0] = -kTrayCCablesZLenOut;
+ yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
+ xprof[1] = sideCMidFace->GetX(5);
+ yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
+ xprof[2] = sideCMidFace->GetX(4);
+ yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
+ xprof[3] = sideCMidFace->GetX(3);
+ yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
+ xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableSectCu , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableSectCu;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableSectCu;
+
+ coaxCablesCu->DefinePolygon(8, xprof, yprof);
+ coaxCablesCu->DefineSection(0, 0);
+ coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
+
+ TGeoXtru *coaxCablesMeg = new TGeoXtru(2);
+
+ xprof[0] = coaxCablesCu->GetX(7);
+ yprof[0] = coaxCablesCu->GetY(7);
+ xprof[1] = coaxCablesCu->GetX(6);
+ yprof[1] = coaxCablesCu->GetY(6);
+ xprof[2] = coaxCablesCu->GetX(5);
+ yprof[2] = coaxCablesCu->GetY(5);
+ xprof[3] = coaxCablesCu->GetX(4);
+ yprof[3] = coaxCablesCu->GetY(4);
+ xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
+ yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
+ InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
+ kCoaxCableHighMeg , xprof[5], yprof[5]);
+ xprof[6] = 0.;
+ yprof[6] = yprof[1] + kCoaxCableHighMeg;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[0] + kCoaxCableHighMeg;
+
+ coaxCablesMeg->DefinePolygon(8, xprof, yprof);
+ coaxCablesMeg->DefineSection(0, 0);
+ coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);
+
+ // To avoid a newly discovered overlap,
+ // transform the two overlapping volumes into a Composite Shape
+ TGeoCompositeShape *trayIntern =
+ new TGeoCompositeShape("ITSSPDInternalTrayC",
+ "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
+ TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
+
+ TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal",
+ trayIntern, medAl);
+
+ traySideCIntern->SetVisibility(kTRUE);
+ traySideCIntern->SetLineColor(6); // Purple
+ traySideCIntern->SetLineWidth(1);
+ traySideCIntern->SetFillColor(traySideCIntern->GetLineColor());
+ traySideCIntern->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid",
+ sideCMidFace, medAl);
+
+ traySideCMidFace->SetVisibility(kTRUE);
+ traySideCMidFace->SetLineColor(6); // Purple
+ traySideCMidFace->SetLineWidth(1);
+ traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
+ traySideCMidFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide",
+ sideCSideFace, medAl);
+
+ traySideCSideFace->SetVisibility(kTRUE);
+ traySideCSideFace->SetLineColor(6); // Purple
+ traySideCSideFace->SetLineWidth(1);
+ traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
+ traySideCSideFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov",
+ sideCShortCover, medAl);
+
+ traySideCShortCover->SetVisibility(kTRUE);
+ traySideCShortCover->SetLineColor(6); // Purple
+ traySideCShortCover->SetLineWidth(1);
+ traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
+ traySideCShortCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
+ sideCLongCover, medAl);
+
+ traySideCLongCover->SetVisibility(kTRUE);
+ traySideCLongCover->SetLineColor(6); // Purple
+ traySideCLongCover->SetLineWidth(1);
+ traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
+ traySideCLongCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
+ horTube, medIn);
+
+ traySideCHorTube->SetVisibility(kTRUE);
+ traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCHorTube->SetLineWidth(1);
+ traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
+ traySideCHorTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
+ horFreon, medFr);
+
+ traySideCHorFreon->SetVisibility(kTRUE);
+ traySideCHorFreon->SetLineColor(kBlue); // Blue
+ traySideCHorFreon->SetLineWidth(1);
+ traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
+ traySideCHorFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
+ incTube, medIn);
+
+ traySideCIncTube->SetVisibility(kTRUE);
+ traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCIncTube->SetLineWidth(1);
+ traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
+ traySideCIncTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
+ incFreon, medFr);
+
+ traySideCIncFreon->SetVisibility(kTRUE);
+ traySideCIncFreon->SetLineColor(kBlue); // Blue
+ traySideCIncFreon->SetLineWidth(1);
+ traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
+ traySideCIncFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
+ outTube, medIn);
+
+ traySideCOutTube->SetVisibility(kTRUE);
+ traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
+ traySideCOutTube->SetLineWidth(1);
+ traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
+ traySideCOutTube->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
+ outFreon, medFr);
+
+ traySideCOutFreon->SetVisibility(kTRUE);
+ traySideCOutFreon->SetLineColor(kBlue); // Blue
+ traySideCOutFreon->SetLineWidth(1);
+ traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
+ traySideCOutFreon->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
+ optFibs, medFibs);
+
+ traySideCOptFibs->SetVisibility(kTRUE);
+ traySideCOptFibs->SetLineColor(kOrange); // Orange
+ traySideCOptFibs->SetLineWidth(1);
+ traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
+ traySideCOptFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
+ lowCablesCu, medCu);
+
+ traySideCLowCabsCu->SetVisibility(kTRUE);
+ traySideCLowCabsCu->SetLineColor(kRed); // Red
+ traySideCLowCabsCu->SetLineWidth(1);
+ traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
+ traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
+ lowCablesPUR, medPUR);
+
+ traySideCLowCabsPUR->SetVisibility(kTRUE);
+ traySideCLowCabsPUR->SetLineColor(kBlack); // Black
+ traySideCLowCabsPUR->SetLineWidth(1);
+ traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
+ traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
+ hiCablesCu, medCu);
+
+ traySideCHiCabsCu->SetVisibility(kTRUE);
+ traySideCHiCabsCu->SetLineColor(kRed); // Red
+ traySideCHiCabsCu->SetLineWidth(1);
+ traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
+ traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
+ hiCablesPUR, medPUR);
+
+ traySideCHiCabsPUR->SetVisibility(kTRUE);
+ traySideCHiCabsPUR->SetLineColor(kBlack); // Black
+ traySideCHiCabsPUR->SetLineWidth(1);
+ traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
+ traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
+ coaxCablesCu, medCu);
+
+ traySideCCoaxCu->SetVisibility(kTRUE);
+ traySideCCoaxCu->SetLineColor(kRed); // Red
+ traySideCCoaxCu->SetLineWidth(1);
+ traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
+ traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
+ coaxCablesMeg, medMeg);
+
+ traySideCCoaxMeg->SetVisibility(kTRUE);
+ traySideCCoaxMeg->SetLineColor(kBlack); // Black
+ traySideCCoaxMeg->SetLineWidth(1);
+ traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
+ traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the trays
+ cableTrayC->AddNode(traySideCIntern,1,0);
+
+ cableTrayC->AddNode(traySideCMidFace,1,0);
+
+ zloc = kTrayCHalfWide - kTrayCThick;
+ cableTrayC->AddNode(traySideCSideFace, 1,
+ new TGeoTranslation( 0, 0, zloc));
+ zloc = -kTrayCHalfWide;
+ cableTrayC->AddNode(traySideCSideFace, 2,
+ new TGeoTranslation( 0, 0, zloc));
+
+ xloc = sideCShortCover->GetDX();
+ yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
+ cableTrayC->AddNode(traySideCShortCover, 1,
+ new TGeoTranslation( xloc, yloc, 0));
+
+ cableTrayC->AddNode(traySideCLongCover,1,0);
+
+ traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
+ traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
+ traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);
+
+ xloc = horTube->GetDz();
+ yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCHorTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.,-90.,90.)));
+
+ xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
+ yloc = sideCMidFace->GetY(4) + incTube->GetRmax() +
+ (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
+ cableTrayC->AddNode(traySideCIncTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
+
+ xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
+ yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
+ 2*outTube->GetRmax();
+ cableTrayC->AddNode(traySideCOutTube, 1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-70.,-90.,90.)));
+
+ zloc = horTube->GetRmax();
+ cableTrayC->AddNode(traySideCOptFibs, 1,
+ new TGeoTranslation( 0, 0, zloc));
+
+ zloc = kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCLowCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCLowCabsPUR, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+
+ zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCHiCabsCu, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+ cableTrayC->AddNode(traySideCHiCabsPUR, 1,
+ new TGeoTranslation( 0, 0,-zloc));
+
+ zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
+ cableTrayC->AddNode(traySideCCoaxCu, 1,
+ new TGeoTranslation( 0, 0, zloc));
+ cableTrayC->AddNode(traySideCCoaxMeg, 1,
+ new TGeoTranslation( 0, 0, zloc));
+
+
+ // Finally put everything in the mother volume
+ for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(cableTrayC,2*jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
+ alpharot += 180;
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(cableTrayC,2*jt+2,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
+ }
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SDD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 5 Jan 2010 Mario Sitta
+// Updated: 26 Feb 2010 Mario Sitta
+// Updated: 06 Sep 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Overall position and rotation of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayARTrans = 408.35 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
+ const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
+ const Double_t kExternTrayZTrans = 823.00 *fgkmm;
+ const Double_t kExternCoverYTrans = 2.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+ const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
+ const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
+ const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
+ const Double_t kForwardCoverLength = 380.00 *fgkmm;
+ const Double_t kForwardCoverWide = 133.00 *fgkmm;
+ const Double_t kForwardCoverHeight = 10.00 *fgkmm;
+ const Double_t kForwardCoverThick = 1.00 *fgkmm;
+
+ const Double_t kExternTrayTotalLen = 1200.00 *fgkmm;
+ const Double_t kExternTrayTotalHeight = 52.00 *fgkmm;
+ const Double_t kExternCoverLen = kExternTrayTotalLen;
+ const Double_t kExternCoverThick = 5.00 *fgkmm;
+ const Double_t kExternCoverSideThick = 3.00 *fgkmm;
+
+ const Int_t kForwardTrayNpoints = 8;
+
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideACoolManifWide = 8.23 *fgkcm;
+ const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
+ const Double_t kSideACoolManifLen = 3.90 *fgkcm;
+ const Double_t kSideACoolManifPOMFrac = 0.0054;
+ const Double_t kSideACoolManifSteelFrac= 0.8850;
+ const Double_t kSideACoolManifWaterFrac= 0.0913;
+ const Double_t kSideACoolManifAlFrac = 0.0183;
+
+ const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
+ const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
+ const Double_t kSideACoolTubesPURFrac = 0.5897;
+ const Double_t kSideACoolTubesWaterFrac= 0.4101;
+ const Double_t kSideACoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideAOptConnWide = 0.90 *fgkcm;
+ const Double_t kSideAOptConnLen = 1.37 *fgkcm;
+ const Double_t kSideAOptConnPBTFrac = 0.5010;
+ const Double_t kSideAOptConnSteelFrac = 0.1784;
+ const Double_t kSideAOptConnAlFrac = 0.3206;
+
+ const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
+
+ const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
+ const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
+ const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
+ const Double_t kSideAInputCablesCu = 0.7404;
+ const Double_t kSideAInputCablesPlast = 0.1269;
+ const Double_t kSideAInputCablesAl = 0.0057;
+ const Double_t kSideAInputCablesKapton = 0.0172;
+ const Double_t kSideAInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
+ const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
+ const Double_t kSideAOutputCablesCu = 0.6783;
+ const Double_t kSideAOutputCablesPlast = 0.1605;
+ const Double_t kSideAOutputCablesAl = 0.0078;
+ const Double_t kSideAOutputCablesKapton= 0.0232;
+ const Double_t kSideAOutputCablesPOLYAX= 0.1302;
+
+ const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
+ const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
+ const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
+ const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
+ const Double_t kSideAPCBBoardsCu = 0.3864;
+ const Double_t kSideAPCBBoardsEpoxy = 0.1486;
+ const Double_t kSideAPCBBoardsPlast = 0.0578;
+ const Double_t kSideAPCBBoardsSteel = 0.1521;
+ const Double_t kSideAPCBBoardsPPS = 0.2551;
+
+
+ // Local variables
+ Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
+ Double_t xloc, yloc, zloc, alpharot, height;
+
+
+ // The whole tray as an assembly
+ TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
+
+
+ // First create all needed shapes
+
+ // The forward tray is very complex and deserves a dedicated method
+ CreateSDDForwardTraySideA(cableTrayA,mgr);
+
+ // The forward cover: a Xtru
+ TGeoXtru *forwardCover = new TGeoXtru(2);
+ forwardCover->SetName("ITSsuppSDDForwCover");
+
+ xprof[0] = kForwardCoverWide/2;
+ yprof[0] = kForwardCoverHeight;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = xprof[1] - kForwardCoverThick;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[0] - kForwardCoverThick;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ forwardCover->DefinePolygon(8, xprof, yprof);
+ forwardCover->DefineSection(0, 0);
+ forwardCover->DefineSection(1, kForwardCoverLength);
+
+ // The external tray (as 0872/G/D/03): a Xtru
+ TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
+ kExternTrayTotalHeight);
+
+ // The external covers: a Composite Shape
+ TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
+
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
+ kSideACoolManifAlFrac*kSideACoolManifHigh/2,
+ kSideACoolManifLen/2);
+
+ // The cooling tubes: three Xtru's
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
+
+ xprof[0] = kSideACoolManifLen;
+ yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
+ xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
+ kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
+ yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
+ kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
+ kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
+ IntersectLines( 0 , xprof[0], yprof[0],
+ TanD(kTrayAZRot), xprof[2], yprof[2],
+ xprof[1], yprof[1]);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
+
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
+
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
+
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+ height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
+ coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
+
+ // The optical fiber connectors: three boxes
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
+ kSideAOptConnAlFrac*kSideACoolManifHigh/2,
+ kSideAOptConnLen/2);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = kSideAOptConnLen;
+ yprof[0] = coolTubesPUR->GetY(0);
+ xprof[1] = coolTubesPUR->GetX(1);
+ yprof[1] = coolTubesPUR->GetY(1);
+ xprof[2] = coolTubesPUR->GetX(2);
+ yprof[2] = coolTubesPUR->GetY(2);
+ xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideAOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideAOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
+
+ // The input cables: five boxes
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesCu*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPlast*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesAl*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesKapton*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
+ kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
+ kSideAInputCablesLen/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
+
+ xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
+ yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
+ kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
+ kSideAPCBBoardsLen/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
+ forwardCover, medAl);
+
+ forwardTrayCover->SetVisibility(kTRUE);
+ forwardTrayCover->SetLineColor(kMagenta+1); // Purple
+ forwardTrayCover->SetLineWidth(1);
+ forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
+ forwardTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
+ externalTray, medAl);
+
+ externalTraySDD->SetVisibility(kTRUE);
+ externalTraySDD->SetLineColor(6); // Purple
+ externalTraySDD->SetLineWidth(1);
+ externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
+ externalTraySDD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
+ externCover, medAntic);
+
+ externTrayCover->SetVisibility(kTRUE);
+ externTrayCover->SetLineColor(kMagenta+1); // Purple
+ externTrayCover->SetLineWidth(1);
+ externTrayCover->SetFillColor(externTrayCover->GetLineColor());
+ externTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
+ zloc = kForwardTrayUpperLength - kForwardCoverLength;
+ cableTrayA->AddNode(forwardTrayCover, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
+ - kExternCoverYTrans;
+
+ yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternTrayTotalHeight*CosD(kTrayAZRot);
+ zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
+ cableTrayA->AddNode(externalTraySDD, 1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
+
+ yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
+ kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
+ zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
+ cableTrayA->AddNode(externTrayCover,1,
+ new TGeoCombiTrans( 0, yloc, zloc,
+ new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
+
+ yloc = kForwardTrayThick + coolManifPOM->GetDY();
+ zloc = coolManifPOM->GetDZ();
+ cableTrayA->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ cableTrayA->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ cableTrayA->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ cableTrayA->AddNode(alCoolManif, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(purCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(waterCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(airCoolTubes,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
+ yloc = kForwardTrayThick + optConnPBT->GetDY();
+ zloc = optConnPBT->GetDZ();
+ cableTrayA->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(pbtOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ cableTrayA->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(steelOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ cableTrayA->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayA->AddNode(alOptConn, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+ xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
+ cableTrayA->AddNode(optFibs,1,
+ new TGeoCombiTrans( xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(optFibs,2,
+ new TGeoCombiTrans(-xloc, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
+ kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
+ zloc = inputCabsPOLYAX->GetDZ();
+ cableTrayA->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
+ cableTrayA->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
+ cableTrayA->AddNode(alInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
+ cableTrayA->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
+ cableTrayA->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
+ zloc += pcbBoardsPPS->GetDZ();
+ cableTrayA->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
+ cableTrayA->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
+ cableTrayA->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
+ cableTrayA->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
+ cableTrayA->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( 0, yloc, zloc) );
+
+ cableTrayA->AddNode(cuOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(plastOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(alOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(kaptonOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+ cableTrayA->AddNode(polyaxOutputCabs,1,
+ new TGeoCombiTrans( 0, 0, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+
+ // Finally put everything in the mother volume
+ Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
+ kExternCoverSideThick -
+ kForwardTrayTailHeight;
+
+ alpharot = -kTrayAFirstRotAng;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
+
+ moth->AddNode(cableTrayA,1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot += 180;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,2,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+ alpharot += 180;
+ xloc = rforw*SinD(alpharot);
+ yloc = rforw*CosD(alpharot);
+ moth->AddNode(cableTrayA,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SDD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 17 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ // Dimensions and positions of the C-Side Cable Tray
+ // (Change accordingly to CreateSDDSSDTraysSideC !)
+ const Int_t kNumTraySideC = 4;
+
+ const Double_t kSideCHalfThick = 0.100 *fgkcm;
+ const Double_t kSideCLength1 = 172.800 *fgkcm;
+ const Double_t kSideCLength2 = 189.300 *fgkcm;
+ const Double_t kBarCoolRmax = 0.4 *fgkcm;
+ const Double_t kXShiftBarCool = 13.00 *fgkcm;
+
+ const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
+
+ // Dimensions and positions of the Cable Tray elements
+ const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
+ const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
+ const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
+ const Double_t kSideCCoolManifPOMFrac = 0.0051;
+ const Double_t kSideCCoolManifSteelFrac= 0.8502;
+ const Double_t kSideCCoolManifWaterFrac= 0.0868;
+ const Double_t kSideCCoolManifAlFrac = 0.0579;
+
+ const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
+ const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
+ const Double_t kSideCCoolTubesPURFrac = 0.5884;
+ const Double_t kSideCCoolTubesWaterFrac= 0.4114;
+ const Double_t kSideCCoolTubesAirFrac = 0.0002;
+
+ const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
+ const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
+ const Double_t kSideCOptConnPBTFrac = 0.6798;
+ const Double_t kSideCOptConnSteelFrac = 0.2421;
+ const Double_t kSideCOptConnAlFrac = 0.0781;
+
+ const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
+ const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
+ const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
+
+ const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
+ const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
+ const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
+ const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
+ const Double_t kSideCInputCablesCu = 0.7405;
+ const Double_t kSideCInputCablesPlast = 0.1268;
+ const Double_t kSideCInputCablesAl = 0.0057;
+ const Double_t kSideCInputCablesKapton = 0.0172;
+ const Double_t kSideCInputCablesPOLYAX = 0.1098;
+
+ const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
+ const Double_t kSideCOutputCablesWide = 8.50 *fgkcm;
+ const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
+ const Double_t kSideCOutputCablesCu = 0.6775;
+ const Double_t kSideCOutputCablesPlast = 0.1613;
+ const Double_t kSideCOutputCablesAl = 0.0078;
+ const Double_t kSideCOutputCablesKapton= 0.0234;
+ const Double_t kSideCOutputCablesPOLYAX= 0.1300;
+
+ const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
+ const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
+ const Double_t kSideCPCBBoardsCu = 0.3864;
+ const Double_t kSideCPCBBoardsEpoxy = 0.1491;
+ const Double_t kSideCPCBBoardsPlast = 0.0579;
+ const Double_t kSideCPCBBoardsSteel = 0.1517;
+ const Double_t kSideCPCBBoardsPPS = 0.2549;
+
+ // Overall position and rotation of the C-Side Cable Trays
+ const Double_t kTraySideCRPos = 45.30 *fgkcm;
+ const Double_t kTraySideCZPos = -102.40 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0,
+ /* from SSD tray position */ 180.-23.0, 180.+59.0};
+
+
+ // Local variables
+ Double_t xprof[6], yprof[6];
+ Double_t height, xloc, yloc, zloc, alpharot, alphafold;
+
+
+ // The assembly holding the metallic structure
+ TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
+
+ // Now the volumes inside it
+ // The cooling manifold: four boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
+ kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
+ kSideCCoolManifHalfX);
+
+ // The cooling tubes: three Xtru's
+ alpharot = kSideCFoldAngle*TMath::DegToRad();
+
+ TGeoXtru *coolTubesPUR = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
+
+ xprof[0] = 2*kSideCCoolManifHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesPUR->DefinePolygon(6, xprof, yprof);
+ coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesWater = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
+
+ xprof[0] = coolTubesPUR->GetX(5);
+ yprof[0] = coolTubesPUR->GetY(5);
+ xprof[1] = coolTubesPUR->GetX(4);
+ yprof[1] = coolTubesPUR->GetY(4);
+ xprof[2] = coolTubesPUR->GetX(3);
+ yprof[2] = coolTubesPUR->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesWater->DefinePolygon(6, xprof, yprof);
+ coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
+
+ TGeoXtru *coolTubesAir = new TGeoXtru(2);
+
+ height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
+
+ xprof[0] = coolTubesWater->GetX(5);
+ yprof[0] = coolTubesWater->GetY(5);
+ xprof[1] = coolTubesWater->GetX(4);
+ yprof[1] = coolTubesWater->GetY(4);
+ xprof[2] = coolTubesWater->GetX(3);
+ yprof[2] = coolTubesWater->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ coolTubesAir->DefinePolygon(6, xprof, yprof);
+ coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
+ coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
+
+ // The optical fiber connectors: three boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
+ kSideCOptConnAlFrac*kSideCCoolManifHalfY,
+ kSideCOptConnHalfX);
+
+ // The optical fibers: a Xtru
+ TGeoXtru *opticalFibs = new TGeoXtru(2);
+
+ xprof[0] = 2*kSideCOptConnHalfZ;
+ yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
+ xprof[1] = kSideCLength1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
+ xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideCOptFibsHigh, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kSideCOptFibsHigh;
+
+ opticalFibs->DefinePolygon(6, xprof, yprof);
+ opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
+ opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
+
+ // The input cables: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesCu*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPlast*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesAl*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesKapton*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
+ kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
+ kSideCInputCablesWide/2);
+
+ // The output cables: five Xtru
+ TGeoXtru *outputCabsCu = new TGeoXtru(2);
+
+ height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
+
+ xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
+ yprof[0] = coolTubesAir->GetY(5);
+ xprof[1] = coolTubesAir->GetX(4);
+ yprof[1] = coolTubesAir->GetY(4);
+ xprof[2] = coolTubesAir->GetX(3);
+ yprof[2] = coolTubesAir->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsCu->DefinePolygon(6, xprof, yprof);
+ outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPlast = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsCu->GetX(5);
+ yprof[0] = outputCabsCu->GetY(5);
+ xprof[1] = outputCabsCu->GetX(4);
+ yprof[1] = outputCabsCu->GetY(4);
+ xprof[2] = outputCabsCu->GetX(3);
+ yprof[2] = outputCabsCu->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPlast->DefinePolygon(6, xprof, yprof);
+ outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsAl = new TGeoXtru(2);
+
+ height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsPlast->GetX(5);
+ yprof[0] = outputCabsPlast->GetY(5);
+ xprof[1] = outputCabsPlast->GetX(4);
+ yprof[1] = outputCabsPlast->GetY(4);
+ xprof[2] = outputCabsPlast->GetX(3);
+ yprof[2] = outputCabsPlast->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsAl->DefinePolygon(6, xprof, yprof);
+ outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsKapton = new TGeoXtru(2);
+
+ height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsAl->GetX(5);
+ yprof[0] = outputCabsAl->GetY(5);
+ xprof[1] = outputCabsAl->GetX(4);
+ yprof[1] = outputCabsAl->GetY(4);
+ xprof[2] = outputCabsAl->GetX(3);
+ yprof[2] = outputCabsAl->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsKapton->DefinePolygon(6, xprof, yprof);
+ outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
+
+ TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
+
+ height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
+
+ xprof[0] = outputCabsKapton->GetX(5);
+ yprof[0] = outputCabsKapton->GetY(5);
+ xprof[1] = outputCabsKapton->GetX(4);
+ yprof[1] = outputCabsKapton->GetY(4);
+ xprof[2] = outputCabsKapton->GetX(3);
+ yprof[2] = outputCabsKapton->GetY(3);
+ xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
+ yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ height, xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + height;
+
+ outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
+ outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
+ outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
+
+ // The PCB boards: five boxes
+ // (X and Z are inverted on tray reference system)
+ TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+ TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
+ kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
+ kSideCPCBBoardsHalfX);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
+ TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
+ TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+ TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
+ TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
+ TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
+ TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
+ TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
+
+ TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
+ coolManifPOM, medPOM);
+
+ pomCoolManif->SetVisibility(kTRUE);
+ pomCoolManif->SetLineColor(kRed); // Red
+ pomCoolManif->SetLineWidth(1);
+ pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
+ pomCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
+ coolManifSteel, medSteel);
+
+ steelCoolManif->SetVisibility(kTRUE);
+ steelCoolManif->SetLineColor(kBlue); // Blue
+ steelCoolManif->SetLineWidth(1);
+ steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
+ steelCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
+ coolManifWater, medWater);
+
+ waterCoolManif->SetVisibility(kTRUE);
+ waterCoolManif->SetLineColor(33); // Light Blue
+ waterCoolManif->SetLineWidth(1);
+ waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
+ waterCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
+ coolManifAl, medAl);
+
+ alCoolManif->SetVisibility(kTRUE);
+ alCoolManif->SetLineColor(6); // Purple
+ alCoolManif->SetLineWidth(1);
+ alCoolManif->SetFillColor(alCoolManif->GetLineColor());
+ alCoolManif->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
+ coolTubesPUR, medPUR);
+
+ purCoolTubes->SetVisibility(kTRUE);
+ purCoolTubes->SetLineColor(kRed); // Red
+ purCoolTubes->SetLineWidth(1);
+ purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
+ purCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
+ coolTubesWater, medWater);
+
+ waterCoolTubes->SetVisibility(kTRUE);
+ waterCoolTubes->SetLineColor(33); // Light Blue
+ waterCoolTubes->SetLineWidth(1);
+ waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
+ waterCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
+ coolTubesAir, medAir);
+
+ airCoolTubes->SetVisibility(kTRUE);
+ airCoolTubes->SetLineColor(41);
+ airCoolTubes->SetLineWidth(1);
+ airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
+ airCoolTubes->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
+ optConnPBT, medPBT);
+
+ pbtOptConn->SetVisibility(kTRUE);
+ pbtOptConn->SetLineColor(kRed); // Red
+ pbtOptConn->SetLineWidth(1);
+ pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
+ pbtOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
+ optConnSteel, medSteel);
+
+ steelOptConn->SetVisibility(kTRUE);
+ steelOptConn->SetLineColor(kBlue); // Blue
+ steelOptConn->SetLineWidth(1);
+ steelOptConn->SetFillColor(steelOptConn->GetLineColor());
+ steelOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
+ optConnAl, medAl);
+
+ alOptConn->SetVisibility(kTRUE);
+ alOptConn->SetLineColor(6); // Purple
+ alOptConn->SetLineWidth(1);
+ alOptConn->SetFillColor(alOptConn->GetLineColor());
+ alOptConn->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
+ opticalFibs, medOptFib);
+
+ optFibs->SetVisibility(kTRUE);
+ optFibs->SetLineColor(kOrange+2); // Orange
+ optFibs->SetLineWidth(1);
+ optFibs->SetFillColor(optFibs->GetLineColor());
+ optFibs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
+ inputCabsCu, medCu);
+
+ cuInputCabs->SetVisibility(kTRUE);
+ cuInputCabs->SetLineColor(kBlack); // Black
+ cuInputCabs->SetLineWidth(1);
+ cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
+ cuInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
+ inputCabsPlast, medPUR);
+
+ plastInputCabs->SetVisibility(kTRUE);
+ plastInputCabs->SetLineColor(kRed); // Red
+ plastInputCabs->SetLineWidth(1);
+ plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
+ plastInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
+ inputCabsAl, medAl);
+
+ alInputCabs->SetVisibility(kTRUE);
+ alInputCabs->SetLineColor(6); // Purple
+ alInputCabs->SetLineWidth(1);
+ alInputCabs->SetFillColor(alInputCabs->GetLineColor());
+ alInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
+ inputCabsKapton, medKapton);
+
+ kaptonInputCabs->SetVisibility(kTRUE);
+ kaptonInputCabs->SetLineColor(14); //
+ kaptonInputCabs->SetLineWidth(1);
+ kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
+ kaptonInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
+ inputCabsPOLYAX, medPOLYAX);
+
+ polyaxInputCabs->SetVisibility(kTRUE);
+ polyaxInputCabs->SetLineColor(34); //
+ polyaxInputCabs->SetLineWidth(1);
+ polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
+ polyaxInputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
+ outputCabsCu, medCu);
+
+ cuOutputCabs->SetVisibility(kTRUE);
+ cuOutputCabs->SetLineColor(kBlack); // Black
+ cuOutputCabs->SetLineWidth(1);
+ cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
+ cuOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
+ outputCabsPlast, medPUR);
+
+ plastOutputCabs->SetVisibility(kTRUE);
+ plastOutputCabs->SetLineColor(kRed); // Red
+ plastOutputCabs->SetLineWidth(1);
+ plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
+ plastOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
+ outputCabsAl, medAl);
+
+ alOutputCabs->SetVisibility(kTRUE);
+ alOutputCabs->SetLineColor(6); // Purple
+ alOutputCabs->SetLineWidth(1);
+ alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
+ alOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
+ outputCabsKapton, medKapton);
+
+ kaptonOutputCabs->SetVisibility(kTRUE);
+ kaptonOutputCabs->SetLineColor(14); //
+ kaptonOutputCabs->SetLineWidth(1);
+ kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
+ kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
+ outputCabsPOLYAX, medPOLYAX);
+
+ polyaxOutputCabs->SetVisibility(kTRUE);
+ polyaxOutputCabs->SetLineColor(34); //
+ polyaxOutputCabs->SetLineWidth(1);
+ polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
+ polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
+ pcbBoardsCu, medCu);
+
+ cuPCBBoards->SetVisibility(kTRUE);
+ cuPCBBoards->SetLineColor(kBlack); // Black
+ cuPCBBoards->SetLineWidth(1);
+ cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
+ cuPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
+ pcbBoardsEpoxy, medEpoxy);
+
+ epoxyPCBBoards->SetVisibility(kTRUE);
+ epoxyPCBBoards->SetLineColor(22); //
+ epoxyPCBBoards->SetLineWidth(1);
+ epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
+ epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
+ pcbBoardsPlast, medPUR);
+
+ plastPCBBoards->SetVisibility(kTRUE);
+ plastPCBBoards->SetLineColor(kRed); // Red
+ plastPCBBoards->SetLineWidth(1);
+ plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
+ plastPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
+ pcbBoardsSteel, medSteel);
+
+ steelPCBBoards->SetVisibility(kTRUE);
+ steelPCBBoards->SetLineColor(kBlue); // Blue
+ steelPCBBoards->SetLineWidth(1);
+ steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
+ steelPCBBoards->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
+ pcbBoardsPPS, medPPS);
+
+ ppsPCBBoards->SetVisibility(kTRUE);
+ ppsPCBBoards->SetLineColor(kGreen); // Green
+ ppsPCBBoards->SetLineWidth(1);
+ ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
+ ppsPCBBoards->SetFillStyle(4000); // 0% transparent
+
+
+ // Now fill the tray
+ xloc = coolManifPOM->GetDX();
+ yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
+ trayStructure->AddNode(pomCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
+ trayStructure->AddNode(steelCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
+ trayStructure->AddNode(waterCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
+ trayStructure->AddNode(alCoolManif, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ xloc = inputCabsCu->GetDX();
+ yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
+ + kSideCInputCablesTrans;
+ trayStructure->AddNode(cuInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
+ trayStructure->AddNode(plastInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
+ trayStructure->AddNode(alInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
+ trayStructure->AddNode(kaptonInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
+ trayStructure->AddNode(polyaxInputCabs, 1,
+ new TGeoTranslation( xloc, yloc, 0) );
+
+ trayStructure->AddNode(purCoolTubes , 1, 0);
+ trayStructure->AddNode(waterCoolTubes, 1, 0);
+ trayStructure->AddNode(airCoolTubes , 1, 0);
+
+ xloc = optConnPBT->GetDX();
+ yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
+ zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
+ trayStructure->AddNode(pbtOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(pbtOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
+ trayStructure->AddNode(steelOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(steelOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ yloc += optConnSteel->GetDY() + optConnAl->GetDY();
+ trayStructure->AddNode(alOptConn, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ trayStructure->AddNode(alOptConn, 2,
+ new TGeoTranslation( xloc, yloc,-zloc) );
+
+ trayStructure->AddNode(optFibs, 1,
+ new TGeoTranslation( 0, 0, zloc) );
+ trayStructure->AddNode(optFibs, 2,
+ new TGeoTranslation( 0, 0,-zloc) );
+
+ trayStructure->AddNode(cuOutputCabs , 1, 0);
+ trayStructure->AddNode(plastOutputCabs , 1, 0);
+ trayStructure->AddNode(alOutputCabs , 1, 0);
+ trayStructure->AddNode(kaptonOutputCabs, 1, 0);
+ trayStructure->AddNode(polyaxOutputCabs, 1, 0);
+
+ xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
+ yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
+ trayStructure->AddNode(cuPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
+ trayStructure->AddNode(epoxyPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
+ trayStructure->AddNode(plastPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
+ trayStructure->AddNode(steelPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+ yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
+ trayStructure->AddNode(ppsPCBBoards, 1,
+ new TGeoTranslation( xloc, yloc , 0) );
+
+
+ // Finally put everything in the mother volume
+ alphafold = kSideCFoldAngle;
+
+ for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(trayStructure,jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
+ }
+
+
+ return;
+}
+
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side A
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 30 Dec 2009 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello and
+// Ton van den Brink
+// Cables and cooling tubes are approximated with proper materials and
+// rectangular cross sections, always preserving the total material budget.
+//
+
+ // Dimensions and positions of the A-Side Cable Trays
+ // (parts of 0872/G/D)
+ const Double_t kTrayARTrans = 408.35 *fgkmm;
+ const Double_t kTrayAZTrans = 1011.00 *fgkmm;
+ const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kCoversYTrans = 2.00 *fgkmm;
+ const Double_t kTrayAZRot = (180-169.5);// Degrees
+ const Double_t kTrayAFirstRotAng = 22.00; // Degrees
+ const Double_t kTrayASecondRotAng = 15.00; // Degrees
+
+ const Double_t kTrayTotalHeight = 52.00 *fgkmm;
+ const Double_t kTrayHeighToBend = 32.00 *fgkmm;
+ const Double_t kTrayWidth = 130.00 *fgkmm;
+ const Double_t kTrayThick = 2.00 *fgkmm;
+
+ const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
+
+ const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
+ const Double_t kForwardTrayFirstLen = 350.00 *fgkmm;
+ const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm;
+ const Double_t kForwardCoverLen = 420.00 *fgkmm;
+
+ const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
+ const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!!
+ const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!!
+
+ const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm;
+ const Double_t kExternalCoverLen = kExternalTrayTotalLen;
+ const Double_t kExternalCoverThick = 5.00 *fgkmm;
+
+ const Int_t kForwardTrayNpoints = 16;
+
+ const Double_t kServicesWidth = 100.00 *fgkmm;
+ const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
+ const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
+ const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
+ const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
+
+
+ // Local variables
+ Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
+ Double_t xloc, yloc, zloc, alpharot, totalhi;
+
+
+ // The two tray components as assemblies
+ TGeoVolumeAssembly *cableTrayAForw =
+ new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
+ TGeoVolumeAssembly *cableTrayAExt =
+ new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
+
+
+ // First create all needed shapes
+
+ // The first part of the forward tray (part of 0872/G/D/07): a Xtru
+ TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
+
+ xprof[3] = kTrayWidth/2;
+ yprof[3] = kForwardTrayFirstHeight;
+ xprof[2] = xprof[3] - kTrayThick;
+ yprof[2] = yprof[3];
+ xprof[4] = xprof[3];
+ yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
+ xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
+ yprof[5] = 0;
+
+ InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
+ -kTrayThick, xprof[1], yprof[1]);
+
+ xprof[6] = -xprof[5];
+ yprof[6] = yprof[5];
+
+ InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
+ -kTrayThick, xprof[0], yprof[0]);
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 6; jp++) {
+ xprof[6+jp] = -xprof[5-jp];
+ yprof[6+jp] = yprof[5-jp];
+ }
+
+ // And now the actual Xtru
+ forwTrayPart1->DefinePolygon(12, xprof, yprof);
+ forwTrayPart1->DefineSection(0, 0);
+ forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
+
+ // The second part of the forward tray (part of 0872/G/D/07): a Xtru
+ TGeoXtru *forwTrayPart2 =
+ CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
+ kTrayTotalHeight);
+
+ // The external tray (as 0872/G/D/03): a Xtru with same profile
+ TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
+ kTrayTotalHeight);
+
+ // The side wall of the forward tray: a BBox
+ TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
+ kForwardSideHeight/2,
+ kForwardSideLength/2);
+
+ // The side cover over the walls: a Xtru
+ TGeoXtru *forwSideCover = new TGeoXtru(2);
+ forwSideCover->SetName("ITSsuppSSDForwCover");
+
+ xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
+ yprof[0] = kForwardCoverHeight;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = xprof[1] - kForwardSideThick;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[0] - kForwardSideThick;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ forwSideCover->DefinePolygon(8, xprof, yprof);
+ forwSideCover->DefineSection(0, 0);
+ forwSideCover->DefineSection(1, kForwardSideLength);
+
+ // The forward and external covers: two Composite Shape's
+ TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
+
+ TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
+
+ // The cable copper inside the forward tray: a BBox
+ TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
+ kCopperHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cable copper inside the forward tray: a Xtru
+ TGeoXtru *extCopper = new TGeoXtru(2);
+ extCopper->SetName("ITSsuppSSDExtTrayCopper");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCopperHeight;
+ totalhi -= kCopperHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extCopper->DefinePolygon(4, xprof, yprof);
+ extCopper->DefineSection(0, 0);
+ extCopper->DefineSection(1, kServicesWidth);
+
+ // The cable plastic inside the forward tray: a BBox
+ TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
+ kCablePlasticHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cable plastic inside the forward tray: a Xtru
+ TGeoXtru *extPlastic = new TGeoXtru(2);
+ extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCablePlasticHeight;
+ totalhi -= kCablePlasticHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extPlastic->DefinePolygon(4, xprof, yprof);
+ extPlastic->DefineSection(0, 0);
+ extPlastic->DefineSection(1, kServicesWidth);
+
+ // The cooling water inside the forward tray: a BBox
+ TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
+ kCoolingWaterHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The cooling water inside the forward tray: a Xtru
+ TGeoXtru *extWater = new TGeoXtru(2);
+ extWater->SetName("ITSsuppSSDExtTrayWater");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight - kCablePlasticHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kCoolingWaterHeight;
+ totalhi -= kCoolingWaterHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extWater->DefinePolygon(4, xprof, yprof);
+ extWater->DefineSection(0, 0);
+ extWater->DefineSection(1, kServicesWidth);
+
+ // The polyurethane inside the forward tray: a BBox
+ TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
+ kPoliUrethaneHeight/2,
+ kForwardTrayTotalLen/2);
+
+ // The poliurethane inside the forward tray: a Xtru
+ TGeoXtru *extPUR = new TGeoXtru(2);
+ extPUR->SetName("ITSsuppSSDExtTrayPUR");
+
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
+ - kTrayThick - kCopperHeight - kCablePlasticHeight
+ - kCoolingWaterHeight;
+
+ xprof[0] = -totalhi*TanD(kTrayAZRot);
+ yprof[0] = kTrayThick;
+ xprof[1] = kExternalTrayTotalLen;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kPoliUrethaneHeight;
+ totalhi -= kPoliUrethaneHeight;
+ xprof[3] = -totalhi*TanD(kTrayAZRot);
+ yprof[3] = yprof[2];
+
+ extPUR->DefinePolygon(4, xprof, yprof);
+ extPUR->DefineSection(0, 0);
+ extPUR->DefineSection(1, kServicesWidth);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+ TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
+ TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+
+ TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
+ forwTrayPart1, medAl);
+
+ forwTrayFirst->SetVisibility(kTRUE);
+ forwTrayFirst->SetLineColor(6); // Purple
+ forwTrayFirst->SetLineWidth(1);
+ forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
+ forwTrayFirst->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
+ forwTrayPart2, medAl);
+
+ forwTraySecond->SetVisibility(kTRUE);
+ forwTraySecond->SetLineColor(6); // Purple
+ forwTraySecond->SetLineWidth(1);
+ forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
+ forwTraySecond->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
+ forwSide, medAl);
+
+ forwTraySide->SetVisibility(kTRUE);
+ forwTraySide->SetLineColor(6); // Purple
+ forwTraySide->SetLineWidth(1);
+ forwTraySide->SetFillColor(forwTraySide->GetLineColor());
+ forwTraySide->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
+ forwSideCover, medAl);
+
+ forwTraySideCover->SetVisibility(kTRUE);
+ forwTraySideCover->SetLineColor(6); // Purple
+ forwTraySideCover->SetLineWidth(1);
+ forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
+ forwTraySideCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
+ externalTray, medAl);
+
+ externalTraySSD->SetVisibility(kTRUE);
+ externalTraySSD->SetLineColor(6); // Purple
+ externalTraySSD->SetLineWidth(1);
+ externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
+ externalTraySSD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
+ forwardCover, medAntic);
+
+ forwardTrayCover->SetVisibility(kTRUE);
+ forwardTrayCover->SetLineColor(kMagenta+1); // Purple
+ forwardTrayCover->SetLineWidth(1);
+ forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
+ forwardTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
+ externCover, medAntic);
+
+ externTrayCover->SetVisibility(kTRUE);
+ externTrayCover->SetLineColor(kMagenta+1); // Purple
+ externTrayCover->SetLineWidth(1);
+ externTrayCover->SetFillColor(externTrayCover->GetLineColor());
+ externTrayCover->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
+ forwCopper, medCu);
+
+ forwCableCu->SetVisibility(kTRUE);
+ forwCableCu->SetLineColor(kRed); // Red
+ forwCableCu->SetLineWidth(1);
+ forwCableCu->SetFillColor(forwCableCu->GetLineColor());
+ forwCableCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
+ extCopper, medCu);
+
+ extCableCu->SetVisibility(kTRUE);
+ extCableCu->SetLineColor(kRed); // Red
+ extCableCu->SetLineWidth(1);
+ extCableCu->SetFillColor(extCableCu->GetLineColor());
+ extCableCu->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
+ forwPlastic, medFEP);
+
+ forwCableFEP->SetVisibility(kTRUE);
+ forwCableFEP->SetLineColor(kYellow); // Yellow
+ forwCableFEP->SetLineWidth(1);
+ forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
+ forwCableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
+ extPlastic, medFEP);
+
+ extCableFEP->SetVisibility(kTRUE);
+ extCableFEP->SetLineColor(kYellow); // Yellow
+ extCableFEP->SetLineWidth(1);
+ extCableFEP->SetFillColor(extCableFEP->GetLineColor());
+ extCableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
+ forwWater, medH2O);
+
+ forwTrayWater->SetVisibility(kTRUE);
+ forwTrayWater->SetLineColor(kBlue); // Blue
+ forwTrayWater->SetLineWidth(1);
+ forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
+ forwTrayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
+ extWater, medH2O);
+
+ extTrayWater->SetVisibility(kTRUE);
+ extTrayWater->SetLineColor(kBlue); // Blue
+ extTrayWater->SetLineWidth(1);
+ extTrayWater->SetFillColor(extTrayWater->GetLineColor());
+ extTrayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
+ forwPUR, medPUR);
+
+ forwPolyUr->SetVisibility(kTRUE);
+ forwPolyUr->SetLineColor(kGray); // Gray
+ forwPolyUr->SetLineWidth(1);
+ forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
+ forwPolyUr->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
+ extPUR, medPUR);
+
+ extPolyUr->SetVisibility(kTRUE);
+ extPolyUr->SetLineColor(kGray); // Gray
+ extPolyUr->SetLineWidth(1);
+ extPolyUr->SetFillColor(extPolyUr->GetLineColor());
+ extPolyUr->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ cableTrayAForw->AddNode(forwTrayFirst, 1, 0);
+
+ cableTrayAForw->AddNode(forwTraySecond, 1,
+ new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
+
+ xloc = kTrayWidth/2 + kForwardSideThick/2;
+ yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
+ zloc = kForwardSideLength/2;
+ cableTrayAForw->AddNode(forwTraySide,1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ cableTrayAForw->AddNode(forwTraySide,2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
+ - kForwardCoverHeight;
+ cableTrayAForw->AddNode(forwTraySideCover,1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ yloc = kTrayTotalHeight - kCoversYTrans;
+ zloc = kForwardTrayTotalLen - kForwardCoverLen;
+ cableTrayAForw->AddNode(forwardTrayCover,1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + forwCopper->GetDY();
+ zloc = forwCopper->GetDZ();
+ cableTrayAForw->AddNode(forwCableCu, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
+ zloc = forwPlastic->GetDZ();
+ cableTrayAForw->AddNode(forwCableFEP, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
+ zloc = forwWater->GetDZ();
+ cableTrayAForw->AddNode(forwTrayWater, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
+ + kCoolingWaterHeight + forwPUR->GetDY();
+ zloc = forwPUR->GetDZ();
+ cableTrayAForw->AddNode(forwPolyUr, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ // To simplify following placement in MARS, origin is on top
+ totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
+
+ yloc = -totalhi;
+ cableTrayAExt->AddNode(externalTraySSD, 1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
+ cableTrayAExt->AddNode(externTrayCover,1,
+ new TGeoTranslation(0, yloc, 0) );
+
+ xloc = extCopper->GetDZ();
+ yloc = -totalhi;
+ cableTrayAExt->AddNode(extCableCu,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extPlastic->GetDZ();
+ yloc = -totalhi + kCopperHeight;
+ cableTrayAExt->AddNode(extCableFEP,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extWater->GetDZ();
+ yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
+ cableTrayAExt->AddNode(extTrayWater,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+ xloc = extPUR->GetDZ();
+ yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
+ cableTrayAExt->AddNode(extPolyUr,1,
+ new TGeoCombiTrans( xloc, yloc, 0,
+ new TGeoRotation("",-90, 90, 90) ) );
+
+
+ // Finally put everything in the mother volume
+ zloc = kTrayAZTrans;
+ Double_t zlocext = zloc + kForwardTrayTotalLen;
+ Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
+
+ alpharot = kTrayAFirstRotAng;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,1,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,1,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,2,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,2,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,3,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,3,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+ alpharot += 180;
+ xloc = kTrayARTrans*SinD(alpharot);
+ yloc = kTrayARTrans*CosD(alpharot);
+ moth->AddNode(cableTrayAForw,4,
+ new TGeoCombiTrans( xloc, yloc, zloc,
+ new TGeoRotation("",-alpharot,0,0) ) );
+ xloc = rExtTray*SinD(alpharot);
+ yloc = rExtTray*CosD(alpharot);
+ moth->AddNode(cableTrayAExt,4,
+ new TGeoCombiTrans( xloc, yloc, zlocext,
+ new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the SSD cable trays which are outside the ITS support cones
+// but still inside the TPC on Side C
+// (part of this code is taken or anyway inspired to ServicesCableSupport
+// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Created: ??? Bjorn S. Nilsen
+// Updated: 15 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ // Dimensions and positions of the C-Side Cable Tray elements
+ const Int_t kNumTraySideC = 4;
+
+ const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
+
+ const Double_t kServicesWidth = 100.00 *fgkmm;
+ const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
+ const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
+ const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
+ const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
+ const Double_t kCablesYtrans = 2.50 *fgkmm;// Avoid ovlps
+
+ // Overall position and rotation of the C-Side Cable Trays
+ const Double_t kTraySideCRPos = 45.30 *fgkcm;
+ const Double_t kTraySideCZPos = -102.40 *fgkcm;
+ const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0,
+ /* from Patch panel position */ 180.+23.0, 180.-59.0};
+
+
+ // Local variables
+ Double_t xprof[6], yprof[6];
+ Double_t xloc, yloc, alpharot, alphafold;
+
+
+ // The assembly holding the metallic structure
+ TGeoVolumeAssembly *trayStructure =
+ CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");
+
+ // The cable copper inside the tray: a Xtru
+ TGeoXtru *copper = new TGeoXtru(2);
+ copper->SetName("ITSsuppSSDTrayCCopper");
+
+ // Copper lies on the lower plate: get position of its points
+ TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
+ xprof[0] = lowerplate->GetX(5);
+ yprof[0] = lowerplate->GetY(5) + kCablesYtrans;
+ xprof[1] = lowerplate->GetX(4);
+ yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
+ xprof[2] = lowerplate->GetX(3);
+ yprof[2] = lowerplate->GetY(3) + kCablesYtrans;
+ xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kCopperHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCopperHeight;
+
+ copper->DefinePolygon(6, xprof, yprof);
+ copper->DefineSection(0, -kServicesWidth/2);
+ copper->DefineSection(1, kServicesWidth/2);
+
+ // The cable plastic inside the tray: a Xtru
+ TGeoXtru *plastic = new TGeoXtru(2);
+ plastic->SetName("ITSsuppSSDTrayCPlastic");
+
+ xprof[0] = copper->GetX(5);
+ yprof[0] = copper->GetY(5);
+ xprof[1] = copper->GetX(4);
+ yprof[1] = copper->GetY(4);
+ xprof[2] = copper->GetX(3);
+ yprof[2] = copper->GetY(3);
+ xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kCablePlasticHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCablePlasticHeight;
+
+ plastic->DefinePolygon(6, xprof, yprof);
+ plastic->DefineSection(0, -kServicesWidth/2);
+ plastic->DefineSection(1, kServicesWidth/2);
+
+ // The cooling water inside the tray: a Xtru
+ TGeoXtru *water = new TGeoXtru(2);
+ water->SetName("ITSsuppSSDTrayCWater");
+
+ xprof[0] = plastic->GetX(5);
+ yprof[0] = plastic->GetY(5);
+ xprof[1] = plastic->GetX(4);
+ yprof[1] = plastic->GetY(4);
+ xprof[2] = plastic->GetX(3);
+ yprof[2] = plastic->GetY(3);
+ xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kCoolingWaterHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kCoolingWaterHeight;
+
+ water->DefinePolygon(6, xprof, yprof);
+ water->DefineSection(0, -kServicesWidth/2);
+ water->DefineSection(1, kServicesWidth/2);
+
+ // The poliurethane inside the tray: a Xtru
+ TGeoXtru *pur = new TGeoXtru(2);
+ pur->SetName("ITSsuppSSDTrayCPUR");
+ xprof[0] = water->GetX(5);
+ yprof[0] = water->GetY(5);
+ xprof[1] = water->GetX(4);
+ yprof[1] = water->GetY(4);
+ xprof[2] = water->GetX(3);
+ yprof[2] = water->GetY(3);
+ xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPoliUrethaneHeight , xprof[4], yprof[4]);
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[0] + kPoliUrethaneHeight;
+
+ pur->DefinePolygon(6, xprof, yprof);
+ pur->DefineSection(0, -kServicesWidth/2);
+ pur->DefineSection(1, kServicesWidth/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
+ TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
+ TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
+ TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
+
+ TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
+ copper, medCu);
+
+ copperCable->SetVisibility(kTRUE);
+ copperCable->SetLineColor(kRed); // Red
+ copperCable->SetLineWidth(1);
+ copperCable->SetFillColor(copperCable->GetLineColor());
+ copperCable->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
+ plastic, medFEP);
+
+ cableFEP->SetVisibility(kTRUE);
+ cableFEP->SetLineColor(kYellow); // Yellow
+ cableFEP->SetLineWidth(1);
+ cableFEP->SetFillColor(cableFEP->GetLineColor());
+ cableFEP->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
+ water, medH2O);
+
+ trayWater->SetVisibility(kTRUE);
+ trayWater->SetLineColor(kBlue); // Blue
+ trayWater->SetLineWidth(1);
+ trayWater->SetFillColor(trayWater->GetLineColor());
+ trayWater->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
+ pur, medPUR);
+
+ trayPolyUr->SetVisibility(kTRUE);
+ trayPolyUr->SetLineColor(kGray); // Gray
+ trayPolyUr->SetLineWidth(1);
+ trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
+ trayPolyUr->SetFillStyle(4000); // 0% transparent
+
+
+ // Now fill in the tray
+ trayStructure->AddNode(copperCable,1,0);
+ trayStructure->AddNode(cableFEP,1,0);
+ trayStructure->AddNode(trayWater,1,0);
+ trayStructure->AddNode(trayPolyUr,1,0);
+
+
+ // Finally put everything in the mother volume
+ alphafold = kSideCFoldAngle;
+
+ for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
+ alpharot = kTraySideCAlphaRot[jt];
+ xloc = kTraySideCRPos*SinD(alpharot);
+ yloc = kTraySideCRPos*CosD(alpharot);
+ moth->AddNode(trayStructure,jt+1,
+ new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
+ new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
+ }
+
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
+ const TGeoManager *mgr){
+//
+// Creates the forward SDD tray on Side A (0872/G/D/01)
+//
+// Input:
+// tray : the TGeoVolumeAssembly to put the elements in
+// mgr : the GeoManager (used only to get the proper material)
+//
+// Output:
+//
+// Return:
+//
+// Created: 08 Jan 2010 Mario Sitta
+// Updated: 07 Sep 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
+ const Double_t kForwardTrayThick = 2.00 *fgkmm;
+ const Double_t kForwardTraySideLength = 823.00 *fgkmm;
+ const Double_t kForwardTrayTailLength = 212.00 *fgkmm;
+ const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm;
+ const Double_t kForwardTrayNotchLength = 47.20 *fgkmm;
+ const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm;
+ const Double_t kForwardTrayNotchDown = 10.00 *fgkmm;
+ const Double_t kForwardTraySide1Height = 39.00 *fgkmm;
+ const Double_t kForwardTraySide2Height = 26.00 *fgkmm;
+ const Double_t kForwardTraySide2Expand = 10.50 *fgkmm;
+ const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm;
+ const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm;
+ const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm;
+ const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm;
+ const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm;
+ const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm;
+
+ const Int_t kForwardTraySideNpoints = 9;
+
+
+ // Local variables
+ Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
+ Double_t ylen, zlen;
+ Double_t xloc, yloc, zloc;
+
+
+ // The tray has a very complex shape, so it is made by assembling
+ // different elements (with some small simplifications)
+
+ // The tray base: a BBox
+ zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
+ TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
+ kForwardTrayThick/2, zlen);
+
+ // The first part of the side wall: a Xtru
+ TGeoXtru *traySide1 = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = kForwardTrayThick;
+ xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
+ yprof[1] = yprof[0];
+ xprof[2] = kForwardTraySideLength;
+ yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
+ xprof[3] = 0;
+ yprof[3] = yprof[2];
+
+ traySide1->DefinePolygon(4, xprof, yprof);
+ traySide1->DefineSection(0, 0);
+ traySide1->DefineSection(1, kForwardTrayThick);
+
+ // The second part of the side wall: a Xtru
+ TGeoXtru *traySide2 = new TGeoXtru(2);
+
+ xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
+ yprof[0] = traySide1->GetY(2);
+ xprof[1] = kForwardTrayBaseHalfWide;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1] + kForwardTraySide2Expand;
+ yprof[2] = yprof[1] + kForwardTraySide2Height;
+ xprof[3] = xprof[2] - kForwardTrayThick;
+ yprof[3] = yprof[2];
+
+ traySide2->DefinePolygon(4, xprof, yprof);
+ traySide2->DefineSection(0, 0);
+ traySide2->DefineSection(1, kForwardTraySideLength);
+
+ // The third part of the side wall: a Xtru
+ TGeoXtru *traySide3 = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = traySide2->GetY(2);
+ xprof[1] = kForwardTraySideLength;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
+ xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
+ xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[5] - kForwardTrayNotchHeight;
+ xprof[7] = xprof[6] + kForwardTrayNotchLength;
+ yprof[7] = yprof[6];
+ xprof[8] = xprof[7];
+ yprof[8] = yprof[7] - kForwardTrayNotchDown;
+
+ traySide3->DefinePolygon(9, xprof, yprof);
+ traySide3->DefineSection(0, 0);
+ traySide3->DefineSection(1, kForwardTrayThick);
+
+ // The horizontal wing: a BBox
+ TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
+ kForwardTrayThick/2,
+ kForwardTraySide3TailLen/2);
+
+ // The vertical wing: a BBox
+ ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
+ TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
+ ylen, kForwardTrayThick/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+
+ TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
+ trayBase, medAl);
+
+ forwTrayBase->SetVisibility(kTRUE);
+ forwTrayBase->SetLineColor(6); // Purple
+ forwTrayBase->SetLineWidth(1);
+ forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
+ forwTrayBase->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
+ traySide1, medAl);
+
+ forwTraySide1->SetVisibility(kTRUE);
+ forwTraySide1->SetLineColor(6); // Purple
+ forwTraySide1->SetLineWidth(1);
+ forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
+ forwTraySide1->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
+ traySide2, medAl);
+
+ forwTraySide2->SetVisibility(kTRUE);
+ forwTraySide2->SetLineColor(6); // Purple
+ forwTraySide2->SetLineWidth(1);
+ forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
+ forwTraySide2->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
+ traySide3, medAl);
+
+ forwTraySide3->SetVisibility(kTRUE);
+ forwTraySide3->SetLineColor(6); // Purple
+ forwTraySide3->SetLineWidth(1);
+ forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
+ forwTraySide3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
+ trayHorWing, medAl);
+
+ forwTrayHWing->SetVisibility(kTRUE);
+ forwTrayHWing->SetLineColor(6); // Purple
+ forwTrayHWing->SetLineWidth(1);
+ forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
+ forwTrayHWing->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
+ trayVertWing, medAl);
+
+ forwTrayVWing->SetVisibility(kTRUE);
+ forwTrayVWing->SetLineColor(6); // Purple
+ forwTrayVWing->SetLineWidth(1);
+ forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
+ forwTrayVWing->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ yloc = kForwardTrayThick/2;
+ zloc = zlen;
+ tray->AddNode(forwTrayBase, 1,
+ new TGeoTranslation(0, yloc, zloc) );
+
+ xloc = kForwardTrayBaseHalfWide;
+ tray->AddNode(forwTraySide1, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ xloc = -xloc + kForwardTrayThick;
+ tray->AddNode(forwTraySide1, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ tray->AddNode(forwTraySide2, 1, 0);
+ zloc = kForwardTraySideLength;
+ tray->AddNode(forwTraySide2, 2,
+ new TGeoCombiTrans(0, 0, zloc,
+ new TGeoRotation("",90,-180,-90)));
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
+ tray->AddNode(forwTraySide3, 1,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+ xloc = -xloc + kForwardTrayThick;
+ tray->AddNode(forwTraySide3, 2,
+ new TGeoCombiTrans(xloc, 0, 0,
+ new TGeoRotation("",90,-90,-90)));
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
+ - kForwardTrayHorWingWide/2;
+ yloc = traySide3->GetY(2) + kForwardTrayThick/2;
+ zloc = kForwardTraySideLength - trayHorWing->GetDZ();
+ tray->AddNode(forwTrayHWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayHWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+ xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
+ - kForwardTrayVertWingWide/2;
+ yloc = traySide3->GetY(2) + trayVertWing->GetDY();
+ zloc = traySide3->GetX(3) + kForwardTrayThick/2;
+ tray->AddNode(forwTrayVWing, 1,
+ new TGeoTranslation( xloc, yloc, zloc) );
+ tray->AddNode(forwTrayVWing, 2,
+ new TGeoTranslation(-xloc, yloc, zloc) );
+
+
+ return;
+}
+
+//______________________________________________________________________
+TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
+//
+// Creates the forward cover of the SDD and SSD cable trays on Side A
+// (0872/G/D/02)
+//
+// Input:
+// coverLen: the total length of the cover
+//
+// Output:
+//
+// Return: a TGeoCompositeShape for the cover
+//
+// Created: 03 Jan 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the A-Side Cable Tray Forward Cover
+ // (0872/G/D/02)
+ const Double_t kForwardCoverWide = 130.00 *fgkmm;
+ const Double_t kForwardCoverSideWide = 10.00 *fgkmm;
+ const Double_t kForwardCoverHoleLen = 160.00 *fgkmm;
+ const Double_t kForwardCoverHoleWide = 90.00 *fgkmm;
+ const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm;
+ const Double_t kForwardCoverTotalThick = 5.00 *fgkmm;
+ const Double_t kForwardCoverSideThick = 3.00 *fgkmm;
+ const Double_t kForwardCoverInternThick = 2.00 *fgkmm;
+
+ const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm;
+
+
+ // Local variables
+ Double_t xprof[16], yprof[16];
+ Double_t yloc, zloc;
+
+
+ // The main shape: a Xtru
+ TGeoXtru *forwCoverMain = new TGeoXtru(2);
+ forwCoverMain->SetName("ITSsuppForwCoverMain");
+
+ xprof[0] = kForwardCoverWide/2;
+ yprof[0] = kForwardCoverTotalThick;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] - kForwardCoverSideThick;
+ xprof[2] = xprof[1] - kForwardCoverSideWide;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ // And now the actual Xtru
+ forwCoverMain->DefinePolygon(8, xprof, yprof);
+ forwCoverMain->DefineSection(0, 0);
+ forwCoverMain->DefineSection(1, coverLen);
+
+ // The hole: another Xtru (rounded corners approximated with segments)
+ TGeoXtru *forwCoverHole = new TGeoXtru(2);
+ forwCoverHole->SetName("ITSsuppForwCoverHole");
+
+ CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
+ kForwardCoverHoleR10 , xprof, yprof);
+
+ // And now the actual Xtru
+ forwCoverHole->DefinePolygon(16, xprof, yprof);
+ forwCoverHole->DefineSection(0, 0);
+ forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
+
+ // Now the proper rototranslation matrices for the two holes
+ yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
+ zloc = kForwardCoverHoleZTrans;
+ TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ mf1->SetName("mf1");
+ mf1->RegisterYourself();
+
+ zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
+ TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ mf2->SetName("mf2");
+ mf2->RegisterYourself();
+
+ // Finally the actual cover shape
+ TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
+ "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
+
+ return cover;
+}
+
+//______________________________________________________________________
+TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
+//
+// Creates the external cover of the SDD and SSD cable trays on Side A
+// (0872/G/D/04)
+//
+// Input:
+// coverLen: the total length of the cover
+//
+// Output:
+//
+// Return: a TGeoCompositeShape for the cover
+//
+// Created: 03 Jan 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the A-Side Cable Tray External Cover
+ // (0872/G/D/04)
+ const Double_t kExternalCoverWide = 130.00 *fgkmm;
+ const Double_t kExternalCoverSideWide = 10.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm;
+ const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm;
+ const Double_t kExternalCoverHoleWide = 90.00 *fgkmm;
+ const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm;
+ const Double_t kExternalCoverTotalThick = 5.00 *fgkmm;
+ const Double_t kExternalCoverSideThick = 3.00 *fgkmm;
+ const Double_t kExternalCoverInternThick = 2.00 *fgkmm;
+
+ const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm;
+ const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm;
+
+
+ // Local variables
+ Double_t xprof[16], yprof[16];
+ Double_t yloc, zloc;
+
+
+ // The main shape: a Xtru
+ TGeoXtru *externCoverMain = new TGeoXtru(2);
+ externCoverMain->SetName("ITSsuppExternCoverMain");
+
+ xprof[0] = kExternalCoverWide/2;
+ yprof[0] = kExternalCoverTotalThick;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] - kExternalCoverSideThick;
+ xprof[2] = xprof[1] - kExternalCoverSideWide;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ // And now the actual Xtru
+ externCoverMain->DefinePolygon(8, xprof, yprof);
+ externCoverMain->DefineSection(0, 0);
+ externCoverMain->DefineSection(1, coverLen);
+
+ // The first hole: a Xtru (rounded corners approximated with segments)
+ Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
+
+ TGeoXtru *extCoverHole1 = new TGeoXtru(2);
+ extCoverHole1->SetName("ITSsuppExtCoverHole1");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole1->DefinePolygon(16, xprof, yprof);
+ extCoverHole1->DefineSection(0, 0);
+ extCoverHole1->DefineSection(1, holethick);
+
+ // The second (and third) hole: another Xtru
+ TGeoXtru *extCoverHole2 = new TGeoXtru(2);
+ extCoverHole2->SetName("ITSsuppExtCoverHole2");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole2->DefinePolygon(16, xprof, yprof);
+ extCoverHole2->DefineSection(0, 0);
+ extCoverHole2->DefineSection(1, holethick);
+
+ // The fourth hole: another Xtru
+ TGeoXtru *extCoverHole3 = new TGeoXtru(2);
+ extCoverHole3->SetName("ITSsuppExtCoverHole3");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole3->DefinePolygon(16, xprof, yprof);
+ extCoverHole3->DefineSection(0, 0);
+ extCoverHole3->DefineSection(1, holethick);
+
+ // The fifth and last hole: another Xtru
+ TGeoXtru *extCoverHole4 = new TGeoXtru(2);
+ extCoverHole4->SetName("ITSsuppExtCoverHole4");
+
+ CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
+ kExternalCoverHoleR10 , xprof, yprof);
+
+ extCoverHole4->DefinePolygon(16, xprof, yprof);
+ extCoverHole4->DefineSection(0, 0);
+ extCoverHole4->DefineSection(1, holethick);
+
+ // Now the proper rototranslation matrices for the holes
+ yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
+ zloc = kExternalCoverHole1ZTrans;
+ TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me1->SetName("me1");
+ me1->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me2->SetName("me2");
+ me2->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me3->SetName("me3");
+ me3->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me4->SetName("me4");
+ me4->RegisterYourself();
+
+ zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
+ TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
+ new TGeoRotation("", 0, 90, 0) );
+ me5->SetName("me5");
+ me5->RegisterYourself();
+
+ // Finally the actual cover shape
+ TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
+ "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
+
+ return cover;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
+ const Double_t length, const Double_t r10,
+ Double_t *x, Double_t *y){
+//
+// Creates the proper sequence of X and Y coordinates to determine
+// the base XTru polygon for the holes in the SDD and SSD tray covers
+// (here the rounded corners are approximated with segments)
+//
+// Input:
+// wide : the hole wide
+// length : the hole length
+// r10 : the radius of the rounded corners
+//
+// Output:
+// x, y : coordinate vectors [16]
+//
+// Created: 03 Jan 2010 Mario Sitta
+//
+// Caller must guarantee that x and y have the correct dimensions
+// (but being this a private method it's easy to tell)
+//
+
+ x[0] = wide/2 - r10;
+ y[0] = length;
+ x[1] = x[0] + r10*SinD(30);
+ y[1] = y[0] - r10*(1 - CosD(30));
+ x[2] = x[0] + r10*SinD(60);
+ y[2] = y[0] - r10*(1 - CosD(60));
+ x[3] = x[0] + r10;
+ y[3] = y[0] - r10;
+ x[4] = x[3];
+ y[4] = r10;
+ x[5] = x[4] - r10*(1 - CosD(30));
+ y[5] = y[4] - r10*SinD(30);
+ x[6] = x[4] - r10*(1 - CosD(60));
+ y[6] = y[4] - r10*SinD(60);
+ x[7] = x[4] - r10;
+ y[7] = 0;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 8; jp++) {
+ x[8+jp] = -x[7-jp];
+ y[8+jp] = y[7-jp];
+ }
+
+ return;
+}
+
+//______________________________________________________________________
+TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
+ const Double_t trayLen,
+ const Double_t trayHi){
+//
+// Creates parts of the SDD and SSD Trays on Side A which are identical
+// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
+//
+// Input:
+// trayLen : the length of the tray part
+// trayHi : the height of the tray part
+//
+// Output:
+//
+// Return: a TGeoXtru
+//
+// Created: 26 Feb 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the A-Side Cable Trays
+ // (parts of 0872/G/C)
+ const Double_t kTrayWidth = 130.00 *fgkmm;
+ const Double_t kTrayWingWidth = 10.00 *fgkmm;
+ const Double_t kTrayHeightToBend = 20.00 *fgkmm;
+ const Double_t kTrayThick = 2.00 *fgkmm;
+
+ const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
+
+ const Int_t kTrayNpoints = 16;
+
+ // Local variables
+ Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
+
+
+ // The tray shape: a Xtru
+ TGeoXtru *trayPart = new TGeoXtru(2);
+
+ xprof[2] = kTrayWidth/2 - kTrayThick;
+ yprof[2] = trayHi - kTrayThick;
+ xprof[3] = kTrayWidth/2 - kTrayWingWidth;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = trayHi;
+ xprof[5] = kTrayWidth/2;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = kTrayHeightToBend;
+ xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
+ yprof[7] = 0;
+
+ InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
+ -kTrayThick, xprof[1], yprof[1]);
+
+ xprof[8] = -xprof[7];
+ yprof[8] = yprof[7];
+
+ InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
+ -kTrayThick, xprof[0], yprof[0]);
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 8; jp++) {
+ xprof[8+jp] = -xprof[7-jp];
+ yprof[8+jp] = yprof[7-jp];
+ }
+
+ // And now the actual Xtru
+ trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
+ trayPart->DefineSection(0, 0);
+ trayPart->DefineSection(1, trayLen);
+
+
+ return trayPart;
+}
+
+//______________________________________________________________________
+TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
+ const char *trayName,
+ const TGeoManager *mgr){
+
+//
+// Creates the SDD and SSD Trays on Side C which are supposedly identical
+//
+// Input:
+// trayName : the assembly name
+//
+// Output:
+//
+// Return: a TGeoVolumeAssembly
+//
+// Created: 16 Apr 2010 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings and other (oral)
+// information given by F.Tosello
+//
+
+ const Double_t kSideCHalfThick = 0.100 *fgkcm;
+ const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad();
+
+ const Double_t kSideCLength1 = 172.800 *fgkcm;
+ const Double_t kSideCLength2 = 189.300 *fgkcm;
+ const Double_t kSideCHalfWide = 6.350 *fgkcm;
+ const Double_t kSideCHeight1 = 11.800 *fgkcm;
+ const Double_t kSideCHeight2 = 4.300 *fgkcm;
+ const Double_t kSideCSideLength1 = 10.800 *fgkcm;
+ const Double_t kSideCSideLength2 = 63.800 *fgkcm;
+ const Double_t kSideCSideHeight = 8.800 *fgkcm;
+ const Int_t kNPointsLowerFace = 6;
+ const Int_t kNPointsLateralFace = 9;
+
+ const Double_t kSideCWingAHalfLen = 5.000 *fgkcm;
+ const Double_t kSideCWingBHalfLen = 30.500 *fgkcm;
+ const Double_t kSideCWingCHalfLen = 2.000 *fgkcm;
+ const Double_t kSideCWingDHalfLen = 48.500 *fgkcm;
+ const Double_t kSideCWingEHalfLen = 83.000 *fgkcm;
+ const Double_t kSideCWingsHalfWide = 0.450 *fgkcm;
+
+ const Int_t kNPointsCoverFace = 12;
+
+ const Double_t kPlateHalfLen = 6.000 *fgkcm;
+ const Double_t kPlateThick = 0.600 *fgkcm;
+ const Double_t kPlateHeight = 4.200 *fgkcm;
+ const Int_t kNPointsPlate = 6;
+
+ const Double_t kBarCoolRmax = 0.4 *fgkcm;
+ const Int_t kNumBarCool = 2;
+ const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
+ const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 };
+
+
+ // Local variables
+ Double_t xprof[12], yprof[12];
+ Double_t xloc, yloc, zloc, delta, alpharot;
+
+ // The single C-Side Cable tray as an assembly
+ TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);
+
+ // First create all needed shapes
+
+ // The Cable Tray lower face: a Xtru
+ TGeoXtru *sideCLowerFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kSideCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ 2*kSideCHalfThick , xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = 2*kSideCHalfThick;
+
+ sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
+ sideCLowerFace->DefineSection(0,-kSideCHalfWide);
+ sideCLowerFace->DefineSection(1, kSideCHalfWide);
+
+ // The Cable Tray lateral face: a Xtru
+ TGeoXtru *sideCLateralFace = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kSideCLength1;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kSideCHeight2, xprof[4], yprof[4]);
+ xprof[5] = kSideCSideLength1 + kSideCSideLength2;
+ yprof[5] = kSideCHeight2;
+ xprof[6] = xprof[5];
+ yprof[6] = kSideCSideHeight;
+ xprof[7] = kSideCSideLength1;
+ yprof[7] = kSideCHeight1;
+ xprof[8] = 0;
+ yprof[8] = yprof[7];
+
+ sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
+ sideCLateralFace->DefineSection(0,-kSideCHalfThick);
+ sideCLateralFace->DefineSection(1, kSideCHalfThick);
+
+ // The lateral wings: four BBox's
+ TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these
+ kSideCWingCHalfLen, // X,Y avoid
+ kSideCWingsHalfWide);//rotations
+
+ TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
+ kSideCHalfThick,
+ kSideCWingsHalfWide);
+
+ // The connecting lower plate: a Xtru
+ TGeoXtru *sideCLowerPlate = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kPlateHalfLen;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPlateThick, xprof[4], yprof[4]);
+ xprof[5] = 0.;
+ yprof[5] = kPlateThick;
+
+ sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
+ Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
+ sideCLowerPlate->DefineSection(0,-zwide);
+ sideCLowerPlate->DefineSection(1, zwide);
+
+ // The connecting side plate: a Xtru
+ TGeoXtru *sideCLateralPlate = new TGeoXtru(2);
+
+ xprof[0] = 0.;
+ yprof[0] = 0.;
+ xprof[1] = kPlateHalfLen;
+ yprof[1] = 0.;
+ xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
+ yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
+ xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
+ yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
+ kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
+ xprof[5] = 0.;
+ yprof[5] = kPlateHeight;
+
+ sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
+ sideCLateralPlate->DefineSection(0,-kPlateThick/2);
+ sideCLateralPlate->DefineSection(1, kPlateThick/2);
+
+ // The bar fixing the cooling tubes: a Tube
+ TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);
+
+ // The Cable Tray cover: a (complex) Xtru
+ TGeoXtru *sideCCoverFace = new TGeoXtru(2);
+
+ xprof[ 0] = sideCLateralFace->GetX(8);
+ yprof[ 0] = sideCLateralFace->GetY(8);
+ xprof[ 1] = sideCLateralFace->GetX(7);
+ yprof[ 1] = sideCLateralFace->GetY(7);
+ xprof[ 2] = sideCLateralFace->GetX(6);
+ yprof[ 2] = sideCLateralFace->GetY(6);
+ xprof[ 3] = sideCLateralFace->GetX(5);
+ yprof[ 3] = sideCLateralFace->GetY(5);
+ xprof[ 4] = sideCLateralFace->GetX(4);
+ yprof[ 4] = sideCLateralFace->GetY(4);
+
+ xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
+ delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
+ xprof[ 5] = xprof[4]
+ + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
+ yprof[ 5] = yprof[4]
+ + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);
+
+ xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
+ yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
+ InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
+ 2*kSideCHalfThick, xprof[7], yprof[7]);
+ InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
+ 2*kSideCHalfThick, xprof[8], yprof[8]);
+ xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
+ yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
+ xprof[10] = xprof[1];
+ yprof[10] = yprof[1] + 2*kSideCHalfThick;
+ xprof[11] = xprof[0];
+ yprof[11] = yprof[0] + 2*kSideCHalfThick;
+
+ sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
+ sideCCoverFace->DefineSection(0,-zloc);
+ sideCCoverFace->DefineSection(1, zloc);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
+
+ TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower",
+ sideCLowerFace, medAl);
+
+ traySideCLowerFace->SetVisibility(kTRUE);
+ traySideCLowerFace->SetLineColor(6); // Purple
+ traySideCLowerFace->SetLineWidth(1);
+ traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
+ traySideCLowerFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral",
+ sideCLateralFace, medAl);
+
+ traySideCLateralFace->SetVisibility(kTRUE);
+ traySideCLateralFace->SetLineColor(6); // Purple
+ traySideCLateralFace->SetLineWidth(1);
+ traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
+ traySideCLateralFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingA =
+ new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl);
+
+ traySideCLateralWingA->SetVisibility(kTRUE);
+ traySideCLateralWingA->SetLineColor(6); // Purple
+ traySideCLateralWingA->SetLineWidth(1);
+ traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
+ traySideCLateralWingA->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingB =
+ new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl);
+
+ traySideCLateralWingB->SetVisibility(kTRUE);
+ traySideCLateralWingB->SetLineColor(6); // Purple
+ traySideCLateralWingB->SetLineWidth(1);
+ traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
+ traySideCLateralWingB->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingC =
+ new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl);
+
+ traySideCLateralWingC->SetVisibility(kTRUE);
+ traySideCLateralWingC->SetLineColor(6); // Purple
+ traySideCLateralWingC->SetLineWidth(1);
+ traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
+ traySideCLateralWingC->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingD =
+ new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl);
+
+ traySideCLateralWingD->SetVisibility(kTRUE);
+ traySideCLateralWingD->SetLineColor(6); // Purple
+ traySideCLateralWingD->SetLineWidth(1);
+ traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
+ traySideCLateralWingD->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralWingE =
+ new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl);
+
+ traySideCLateralWingE->SetVisibility(kTRUE);
+ traySideCLateralWingE->SetLineColor(6); // Purple
+ traySideCLateralWingE->SetLineWidth(1);
+ traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
+ traySideCLateralWingE->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLowerPlate =
+ new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl);
+
+ traySideCLowerPlate->SetVisibility(kTRUE);
+ traySideCLowerPlate->SetLineColor(6); // Purple
+ traySideCLowerPlate->SetLineWidth(1);
+ traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
+ traySideCLowerPlate->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCLateralPlate =
+ new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl);
+
+ traySideCLateralPlate->SetVisibility(kTRUE);
+ traySideCLateralPlate->SetLineColor(6); // Purple
+ traySideCLateralPlate->SetLineWidth(1);
+ traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
+ traySideCLateralPlate->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *traySideCCoverFace =
+ new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl);
+
+ traySideCCoverFace->SetVisibility(kTRUE);
+ traySideCCoverFace->SetLineColor(6); // Purple
+ traySideCCoverFace->SetLineWidth(1);
+ traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
+ traySideCCoverFace->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
+ coolBar, medAl);
+
+ coolingTubeBar->SetVisibility(kTRUE);
+ coolingTubeBar->SetLineColor(6); // Purple
+ coolingTubeBar->SetLineWidth(1);
+ coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
+ coolingTubeBar->SetFillStyle(4000); // 0% transparent
+
+
+ // Now build up the tray
+ cableTrayC->AddNode(traySideCLowerFace,1,0);
+
+ zloc = kSideCHalfWide + kSideCHalfThick;
+ cableTrayC->AddNode(traySideCLateralFace,1,
+ new TGeoTranslation(0., 0., zloc) );
+ cableTrayC->AddNode(traySideCLateralFace,2,
+ new TGeoTranslation(0., 0.,-zloc) );
+
+ xloc = kSideCWingAHalfLen;
+ yloc = kSideCHeight1 - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingA,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingA,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ xloc = kSideCSideLength1 + kSideCSideLength2/2;
+ yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
+ kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
+ xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
+ TMath::RadToDeg();
+ cableTrayC->AddNode(traySideCLateralWingB,1,
+ new TGeoCombiTrans(xloc, yloc, zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+ cableTrayC->AddNode(traySideCLateralWingB,2,
+ new TGeoCombiTrans(xloc, yloc,-zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+
+ xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
+ yloc = kSideCSideHeight - kSideCWingCHalfLen;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingC,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingC,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
+ yloc = kSideCHeight2 - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ cableTrayC->AddNode(traySideCLateralWingD,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralWingD,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
+ xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
+ yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
+ kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
+ alpharot = kSideCFoldAngle*TMath::RadToDeg();
+ cableTrayC->AddNode(traySideCLateralWingE,1,
+ new TGeoCombiTrans(xloc, yloc, zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+ cableTrayC->AddNode(traySideCLateralWingE,2,
+ new TGeoCombiTrans(xloc, yloc,-zloc,
+ new TGeoRotation("",alpharot,0,0) ) );
+
+ xloc = kSideCLength1 - kPlateHalfLen;
+ yloc = -kPlateThick -0.0025; // Avoid small overlap
+ cableTrayC->AddNode(traySideCLowerPlate,1,
+ new TGeoTranslation(xloc, yloc, 0.) );
+
+ xloc = kSideCLength1 - kPlateHalfLen;
+ yloc = -kPlateThick;
+ zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
+ cableTrayC->AddNode(traySideCLateralPlate,1,
+ new TGeoTranslation(xloc, yloc, zloc) );
+ cableTrayC->AddNode(traySideCLateralPlate,2,
+ new TGeoTranslation(xloc, yloc,-zloc) );
+
+ for (Int_t jc = 0; jc <kNumBarCool; jc++) {
+ xloc = kXShiftBarCool[jc];
+ yloc = kYShiftBarCool[jc];
+ cableTrayC->AddNode(coolingTubeBar,jc+1,
+ new TGeoTranslation(xloc, yloc, 0.) );
+ }
+
+ cableTrayC->AddNode(traySideCCoverFace,1,0);
+
+
+ // Finally return what we made up
+
+ return cableTrayC;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
+ const TGeoManager *mgr){
+//
+// Creates the elements suspending the ITS to the TPC and other fixed
+// elements used to hook the rails (0872/C and its daughters)
+//
+// Input:
+// moth : the TGeoVolume owing the volume structure
+// mgr : the GeoManager (default gGeoManager)
+// Output:
+//
+// Return:
+//
+// Created: 28 Oct 2010 Mario Sitta
+// Updated: 18 Feb 2011 Mario Sitta
+//
+// Technical data are taken from AutoCAD drawings, L.Simonetti technical
+// drawings and other (oral) information given by F.Tosello
+//
+
+ // Dimensions and positions of the half ring C2/C3 (0872/C/04)
+ const Double_t kRingCZPos = 733.000*fgkmm;
+ const Double_t kRingCZToTPC = 5.500*fgkmm;
+
+ const Double_t kRingCThick = 12.000*fgkmm;
+ const Double_t kRingCRmin = 565.000*fgkmm;
+ const Double_t kRingCRmax = 592.000*fgkmm;
+ const Double_t kRingCHeight = 560.000*fgkmm;
+ const Double_t kRingCXToInsert = 515.000*fgkmm;
+ const Double_t kRingCYToInsert = 113.000*fgkmm;
+
+ const Int_t kNumberOfRingPoints = 23; // N.points to approximate arc
+
+ // Dimensions of the forward upper hook (0872/C/09)
+ const Double_t kForwUpHookThick = 20.000*fgkmm;
+ const Double_t kForwUpHookRext = 590.000*fgkmm;
+ const Double_t kForwUpHookRint = 20.000*fgkmm;
+ const Double_t kForwUpHookHiTot = 89.000*fgkmm;
+ const Double_t kForwUpHookHiInt = 59.000*fgkmm;
+ const Double_t kForwUpHookWide = 96.000*fgkmm;
+ const Double_t kForwUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwUpHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kForwUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kForwUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kForwUpHookHoleY = 8.000*fgkmm;
+ const Double_t kForwUpHookHollowHi = 35.000*fgkmm;
+ const Double_t kForwUpHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwUpHookPts = 11;
+ const Int_t kNumbOfForwUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/08)
+ const Double_t kForwLwHookThick = 20.000*fgkmm;
+ const Double_t kForwLwHookRext = 590.000*fgkmm;
+ const Double_t kForwLwHookRint = 20.000*fgkmm;
+ const Double_t kForwLwHookHiTot = 88.500*fgkmm;
+ const Double_t kForwLwHookWide = 96.000*fgkmm;
+ const Double_t kForwLwHookHalfBase = 25.000*fgkmm;
+ const Double_t kForwLwHookBaseCut = 10.000*fgkmm;
+ const Double_t kForwLwHookYToHollow = 3.500*fgkmm;
+ const Double_t kForwLwHookHoleR = 7.500*fgkmm;
+ const Double_t kForwLwHookHoleIntHi = 35.000*fgkmm;
+ const Double_t kForwLwHookHoleYPos = 13.500*fgkmm;
+ const Double_t kForwLwHookHollowHi = 62.000*fgkmm;
+ const Double_t kForwLwHookHollowWide= 5.000*fgkmm;
+
+ const Int_t kNumberOfForwLwHookPts = 11;
+ const Int_t kNumbOfForwLwHookHolePts= 7;
+
+ // Dimensions of the rear upper hook (0872/C/10)
+ const Double_t kRearUpHookThick = 15.000*fgkmm;
+ const Double_t kRearUpHookRext = 590.000*fgkmm;
+ const Double_t kRearUpHookRint = 20.000*fgkmm;
+ const Double_t kRearUpHookHiTot = 53.500*fgkmm;
+ const Double_t kRearUpHookHiInt = 23.500*fgkmm;
+ const Double_t kRearUpHookWide = 96.000*fgkmm;
+ const Double_t kRearUpHookHalfBase = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleWide = 25.000*fgkmm;
+ const Double_t kRearUpHookHoleHi = 22.500*fgkmm;
+ const Double_t kRearUpHookHoleBase = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleR5 = 5.000*fgkmm;
+ const Double_t kRearUpHookHoleY = 8.000*fgkmm;
+
+ const Int_t kNumberOfRearUpHookPts = 10;
+ const Int_t kNumbOfRearUpHookHolePts= 5;
+
+ // Dimensions of the forward lower hook (0872/C/11)
+ const Double_t kRearLwHookThick = 20.000*fgkmm;
+ const Double_t kRearLwHookRext = 590.000*fgkmm;
+ const Double_t kRearLwHookHiTot = 30.000*fgkmm;
+ const Double_t kRearLwHookWide = 96.000*fgkmm;
+
+ const Int_t kNumberOfRearLwHookPts = 3;
+
+ // Dimensions of the rear lower brackets (0872/C/16)
+ const Double_t kRearLwBracketThick = 15.000*fgkmm;
+ const Double_t kRearLwBracketHi1 = 42.000*fgkmm;
+ const Double_t kRearLwBracketHi2 = 12.000*fgkmm;
+ const Double_t kRearLwBracketWide1 = 34.000*fgkmm;
+ const Double_t kRearLwBracketWide2 = 10.000*fgkmm;
+// const Double_t kRearLwBracketR5 = 5.000*fgkmm
+
+ // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
+ const Double_t kForwWebSStirrDep = 20.000*fgkmm;
+ const Double_t kForwWebSStirrLen1 = 15.000*fgkmm;
+ const Double_t kForwWebSStirrLen2 = 55.000*fgkmm;
+ const Double_t kForwWebSStirrLen3 = 10.000*fgkmm;
+ const Double_t kForwWebSStirrWide1 = 45.000*fgkmm;
+ const Double_t kForwWebSStirrWide2 = 38.000*fgkmm;
+ const Double_t kForwWebSStirrWide3 = 23.000*fgkmm;
+ const Double_t kForwWebTStirrThick = 5.000*fgkmm;
+ const Double_t kForwWebTStirrWide1 = 30.000*fgkmm;
+ const Double_t kForwWebTStirrWide2 = 10.000*fgkmm;
+ const Double_t kForwWebTStirrTotLen3= 58.500*fgkmm;
+ const Double_t kForwWebTStirrTotLen4= 36.000*fgkmm;
+ const Double_t kForwWebTStirrLen1 = 10.000*fgkmm;
+
+ // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
+ const Double_t kFRWebClampThick = 10.000*fgkmm;
+ const Double_t kFRWebClampExtWide = 30.000*fgkmm;
+ const Double_t kFRWebClampIntWide = 18.000*fgkmm;
+ const Double_t kFRWebClampExtHi = 22.000*fgkmm;
+ const Double_t kFRWebClampIntHi = 17.000*fgkmm;
+
+ // Dimensions of the webcam itself
+ const Double_t kWebcamLength = 35.000*fgkmm;//ESTIMATED!!!
+
+ // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
+ const Double_t kRearUpWebStirrWide = 76.000*fgkmm;
+ const Double_t kRearUpWebStirrDep = 15.000*fgkmm;
+ const Double_t kRearUpWebStirrThick = 5.000*fgkmm;
+ const Double_t kRearUpWebStirrH1 = 27.000*fgkmm;
+ const Double_t kRearUpWebStirrH2 = 32.000*fgkmm;
+ const Double_t kRearUpWebBarLen = 130.000*fgkmm;
+ const Double_t kRearUpWebBarHi = 20.000*fgkmm;
+ const Double_t kRearUpWebBarThick = 5.000*fgkmm;
+
+ // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
+ const Double_t kUpperSlideTotHeight = 93.500*fgkmm;
+ const Double_t kUpperSlideBlockHi = 62.500*fgkmm;
+ const Double_t kUpperSlideWidth = 36.000*fgkmm;
+ const Double_t kUpperSlideTotDepth = 51.000*fgkmm;
+ const Double_t kUpperSlideIntDepth = 36.000*fgkmm;
+ const Double_t kUpperSlideStubHi = 15.000*fgkmm;
+ const Double_t kUpperSlideStubDep = 8.000*fgkmm;
+ const Double_t kUpperSlideWheelHi = 18.500*fgkmm;
+ const Double_t kUpperSlideHoleRout = 11.000*fgkmm;
+ const Double_t kUpperSlideHoleRint1 = 9.000*fgkmm;
+ const Double_t kUpperSlideHoleRint2 = 11.500*fgkmm;
+ const Double_t kUpperSlideHoleH1 = 7.000*fgkmm;
+ const Double_t kUpperSlideHoleH2 = 46.000*fgkmm;
+ const Double_t kUpperSlideHoleH3 = 1.100*fgkmm;
+ const Double_t kUpperSlideHoleXPos = 20.000*fgkmm;
+ const Double_t kUpperSlidePinRmin = 4.000*fgkmm;
+ const Double_t kUpperSlidePinRmax = 6.000*fgkmm;
+ const Double_t kUpperSlidePinH1 = 7.000*fgkmm;
+ const Double_t kUpperSlidePinH2 = 46.000*fgkmm;
+ const Double_t kUpperSlidePinH3 = 25.500*fgkmm;
+
+ // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
+ const Double_t kLowerSlideTotHeight = 80.000*fgkmm;
+ const Double_t kLowerSlideBlockHi = 28.000*fgkmm;
+ const Double_t kLowerSlideWidth = 36.000*fgkmm;
+ const Double_t kLowerSlideTotDepth = 60.000*fgkmm;
+ const Double_t kLowerSlideHoleRout = 9.500*fgkmm;
+ const Double_t kLowerSlideHoleRint = 4.700*fgkmm;
+ const Double_t kLowerSlideHoleH1 = 12.000*fgkmm;
+ const Double_t kLowerSlideNoseBase = 40.000*fgkmm;
+ const Double_t kLowerSlideNoseBasHi = 6.000*fgkmm;//Computed
+ const Double_t kLowerSlideNoseUpWid = 25.000*fgkmm;
+ const Double_t kLowerSlideNoseDepth = 10.000*fgkmm;
+ const Double_t kLowerSlidePinRmin = 3.000*fgkmm;
+ const Double_t kLowerSlidePinRmax = 4.000*fgkmm;
+ const Double_t kLowerSlidePinH1 = 12.000*fgkmm;
+ const Double_t kLowerSlidePinH2 = 10.000*fgkmm;
+
+ // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
+ const Double_t kStirrCXPos = 759.000*fgkmm;
+ const Double_t kStirrCZPos = 1867.000*fgkmm;
+
+ const Double_t kStirrC12Thick = 15.000*fgkmm;
+ const Double_t kStirrC12TotLen = 314.000*fgkmm;
+ const Double_t kStirrC12BodyHalfHi = 95.000*fgkmm;
+ const Double_t kStirrC12BodyLen = 153.000*fgkmm;
+ const Double_t kStirrC12HeadLen = 50.000*fgkmm;
+ const Double_t kStirrC12HeadHalfHi = 165.000*fgkmm;
+ const Double_t kStirrC12HeadIntHi = 114.000*fgkmm;
+ const Double_t kStirrC12HeadIntLen = 45.000*fgkmm;
+ const Double_t kStirrC12TailLen = 14.000*fgkmm;
+ const Double_t kStirrC12R100 = 100.000*fgkmm;
+ const Double_t kStirrC12R50 = 50.000*fgkmm;
+ const Double_t kStirrC12R10 = 10.000*fgkmm;
+ const Double_t kStirrC12HeadAng = 40.000; // Degree
+
+ const Int_t kNumberOfStirrCPoints = 23;
+
+ // Dimensions and positions of the C5 rail stirrups (0872/C/05)
+ const Double_t kStirrC5BodyLen = 155.000*fgkmm;
+
+
+ // Local variables
+ Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
+ Double_t xpos, ypos, zpos, alpha;
+ Double_t xdummy, ydummy;
+
+
+ // First create all needed shapes
+
+ // The Supporting Ring (0872/C/04): a really complex Xtru
+ // to approximate the arc with a polyline
+ TGeoXtru *ringC2C3 = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The external arc
+ xprof[j] = kRingCRmax*SinD(90*j/10);
+ yprof[j] = kRingCRmax*CosD(90*j/10);
+ }
+
+ xprof[11] = kRingCRmin;
+ yprof[11] = yprof[10];
+
+ alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
+ xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
+ yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
+ xprof[13] = kRingCRmin*TMath::Cos(alpha);
+ yprof[13] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[14] = kRingCXToInsert;
+ yprof[14] = yprof[13];
+
+ alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
+ xprof[15] = kRingCRmin*TMath::Cos(alpha);
+ yprof[15] = kRingCRmin*TMath::Sin(alpha);
+
+ for (Int_t j=7; j>1; j--) { // The internal arc
+ xprof[23-j] = kRingCRmin*SinD(90*j/10);
+ yprof[23-j] = kRingCRmin*CosD(90*j/10);
+ }
+
+ alpha = TMath::ASin(kRingCHeight/kRingCRmin); // The angle till the notch
+ xprof[22] = kRingCRmin*TMath::Cos(alpha);
+ yprof[22] = kRingCRmin*TMath::Sin(alpha);
+
+ xprof[23] = xprof[0];
+ yprof[23] = yprof[22];
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < 22; jp++) {
+ xprof[24+jp] = -xprof[23-1-jp];
+ yprof[24+jp] = yprof[23-1-jp];
+ }
+
+ // wow! now the actual Xtru
+ ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
+ ringC2C3->DefineSection(0, 0);
+ ringC2C3->DefineSection(1, kRingCThick);
+
+ // The Forward Upper Hook (0872/C/09): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
+ forwUpHookMainBody->SetName("ITSforwUpHookMainBody");
+
+ xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
+ yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
+ xprof[ 1] = kForwUpHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwUpHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
+ yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
+ forwUpHookMainBody->DefineSection(0, 0);
+ forwUpHookMainBody->DefineSection(1, kForwUpHookThick);
+
+ // The hole
+ TGeoXtru *forwUpHookHole = new TGeoXtru(2);
+ forwUpHookHole->SetName("ITSforwUpHookHole");
+
+ xprof[0] = kForwUpHookHoleBase/2;
+ yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
+ xprof[1] = kForwUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
+ xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kForwUpHookHoleR5;
+ yprof[4] = yprof[0] + kForwUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
+ forwUpHookHole->DefineSection(0, -0.1);
+ forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
+ 0.55*kForwUpHookHollowHi,
+ 0.55*kForwUpHookHollowWide);
+ forwUpHookHollow->SetName("ITSforwUpHookHollow");
+
+ TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
+ forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
+ forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
+ forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
+ forwUpHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");
+
+ // The Forward Lower Hook (0872/C/08): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // another Xtru for the hole, and a BBox for the hollow
+ // The main body
+ TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
+ forwLwHookMainBody->SetName("ITSforwLwHookMainBody");
+
+ xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
+ yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
+ xprof[ 1] = kForwLwHookHalfBase;
+ yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
+ xprof[ 2] = xprof[1];
+ yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
+ - kForwLwHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
+ yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
+ }
+ xprof[ 8] = kForwLwHookWide/2;
+ yprof[ 8] = yprof[7];
+ xprof[ 9] = xprof[8];
+ alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
+ yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
+ xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
+ yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
+ xprof[11] = 0;
+ yprof[11] = kForwLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
+ xprof[12+jp] = -xprof[10-jp];
+ yprof[12+jp] = yprof[10-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
+ forwLwHookMainBody->DefineSection(0, 0);
+ forwLwHookMainBody->DefineSection(1, kForwLwHookThick);
+
+ // The hole
+ TGeoXtru *forwLwHookHole = new TGeoXtru(2);
+ forwLwHookHole->SetName("ITSforwLwHookHole");
+
+ xprof[0] = 0;
+ yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
+ - kForwLwHookHoleR;
+ for (Int_t j=1; j<3; j++) {
+ xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
+ yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
+ }
+ xprof[3] = xprof[0] + kForwLwHookHoleR;
+ yprof[3] = yprof[0] + kForwLwHookHoleR;
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
+ for (Int_t j=1; j<3; j++) {
+ xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
+ yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
+ }
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[4] + kForwLwHookHoleR;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
+ xprof[8+jp] = -xprof[6-jp];
+ yprof[8+jp] = yprof[6-jp];
+ }
+
+ // Now the actual Xtru
+ forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
+ forwLwHookHole->DefineSection(0, -0.1);
+ forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);
+
+ // The hollow
+ TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
+ 0.55*kForwLwHookHollowHi,
+ 0.55*kForwLwHookHollowWide);
+ forwLwHookHollow->SetName("ITSforwLwHookHollow");
+
+ TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
+ forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
+ forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
+ forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
+ forwLwHookHollPos->RegisterYourself();
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");
+
+ // The Rear Upper Hook (0872/C/10): a Composite Shape made of
+ // a really complex Xtru to approximate the arc with a polyline,
+ // and another Xtru for the hole
+ // The main body
+ TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
+ rearUpHookMainBody->SetName("ITSrearUpHookMainBody");
+
+ xprof[0] = kRearUpHookHalfBase;
+ yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
+ xprof[1] = xprof[0];
+ yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint);
+ for (Int_t j=1; j<6; j++) {
+ xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
+ yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
+ }
+ xprof[ 7] = kRearUpHookWide/2;
+ yprof[ 7] = yprof[5];
+ xprof[ 8] = xprof[7];
+ alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
+ yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
+ xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
+ yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
+ xprof[10] = 0;
+ yprof[10] = kRearUpHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
+ xprof[11+jp] = -xprof[9-jp];
+ yprof[11+jp] = yprof[9-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
+ rearUpHookMainBody->DefineSection(0, 0);
+ rearUpHookMainBody->DefineSection(1, kRearUpHookThick);
+
+ // The hole
+ TGeoXtru *rearUpHookHole = new TGeoXtru(2);
+ rearUpHookHole->SetName("ITSrearUpHookHole");
+
+ xprof[0] = kRearUpHookHoleBase/2;
+ yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
+ xprof[1] = kRearUpHookHoleWide/2;
+ yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
+ xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
+ yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
+ xprof[4] = xprof[2] - kRearUpHookHoleR5;
+ yprof[4] = yprof[0] + kRearUpHookHoleHi;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
+ xprof[5+jp] = -xprof[4-jp];
+ yprof[5+jp] = yprof[4-jp];
+ }
+
+ // Now the actual Xtru
+ rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
+ rearUpHookHole->DefineSection(0, -0.1);
+ rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);
+
+ // Finally the actual shape: a CompositeShape
+ TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");
+
+ // The Rear Lower Hook (0872/C/11): a Xtru
+ TGeoXtru *rearLwHookShape = new TGeoXtru(2);
+ rearLwHookShape->SetName("ITSrearLwHookShape");
+
+ xprof[0] = kRearLwHookWide/2;
+ yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
+ xprof[1] = xprof[0];
+ alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
+ yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
+ xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
+ yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
+ xprof[3] = 0;
+ yprof[3] = kRearLwHookRext;
+
+ // We did the right side, now reflex on the left side
+ for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
+ xprof[4+jp] = -xprof[2-jp];
+ yprof[4+jp] = yprof[2-jp];
+ }
+
+ // Now the actual Xtru
+ rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
+ rearLwHookShape->DefineSection(0, 0);
+ rearLwHookShape->DefineSection(1, kRearLwHookThick);
+
+ // The Rear Lower Bracket (0872/C/16): a Xtru
+ TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
+ rearLwBrackShape->SetName("ITSrearLwBrackShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[0] + kRearLwBracketHi2;
+ xprof[3] = xprof[2] - kRearLwBracketWide1;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearLwBracketHi1;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ rearLwBrackShape->DefinePolygon(6, xprof, yprof);
+ rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
+ rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);
+
+ // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
+ TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kForwWebSStirrLen1;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kForwWebSStirrWide1;
+ xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kForwWebSStirrWide3;
+ xprof[5] = xprof[4] - kForwWebSStirrLen3;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[0] + kForwWebSStirrWide2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
+ forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
+ forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);
+
+ // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
+ TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);
+
+ xprof[0] = -kForwWebTStirrWide2/2;
+ yprof[0] = 0;
+ xprof[1] = -kForwWebTStirrWide1/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kForwWebTStirrLen1;
+ xprof[3] =-xprof[2];
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[1];
+ xprof[5] =-xprof[0];
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr3Sh->DefineSection(0, 0);
+ forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);
+
+ TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);
+
+ yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
+ yprof[7] = yprof[6];
+
+ forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
+ forwWebTStirr4Sh->DefineSection(0, 0);
+ forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);
+
+ // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
+ TGeoXtru *frWebClampSh = new TGeoXtru(2);
+
+ xprof[0] = kFRWebClampIntWide/2;
+ yprof[0] = kFRWebClampIntHi;
+ xprof[1] = xprof[0];
+ yprof[1] = 0;
+ xprof[2] = kFRWebClampExtWide/2;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = kFRWebClampExtHi;
+ for (Int_t jp = 0; jp < 4; jp++) {
+ xprof[4+jp] = -xprof[3-jp];
+ yprof[4+jp] = yprof[3-jp];
+ }
+
+ frWebClampSh->DefinePolygon(8, xprof, yprof);
+ frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
+ frWebClampSh->DefineSection(1, kFRWebClampThick/2);
+
+ // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
+ TGeoXtru *upWebStirrSh = new TGeoXtru(2);
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
+ xprof[3] = xprof[2] - kRearUpWebStirrThick;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] - kRearUpWebStirrH1;
+ xprof[5] = xprof[4] + kRearUpWebStirrWide;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = yprof[5] + kRearUpWebStirrH2;
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ upWebStirrSh->DefinePolygon(8, xprof, yprof);
+ upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
+ upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);
+
+ // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
+ TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
+ kRearUpWebBarHi/2,
+ kRearUpWebBarThick/2);
+
+ // The Webcam: a BBox
+ TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
+ kWebcamLength/2,
+ kFRWebClampIntHi/2);
+
+ // The Upper Wheel Slide (0872/C/Z/00-01-02)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
+ // (a Pcon) (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *upSlideAirSh = new TGeoXtru(2);
+ upSlideAirSh->SetName("ITSupperSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0];
+ yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
+ xprof[2] = xprof[1] - kUpperSlideIntDepth;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideTotHeight;
+ xprof[4] = xprof[3] + kUpperSlideTotDepth;
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[0];
+
+ upSlideAirSh->DefinePolygon(6, xprof, yprof);
+ upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
+ upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *upSlideAluSh = new TGeoXtru(2);
+ upSlideAluSh->SetName("ITSupperSlideAluShape");
+
+ xprof[0] = upSlideAirSh->GetX(0);
+ yprof[0] = upSlideAirSh->GetY(0);
+ xprof[1] = upSlideAirSh->GetX(1);
+ yprof[1] = upSlideAirSh->GetY(1);
+ xprof[2] = xprof[1] - kUpperSlideStubDep;
+ yprof[2] = yprof[1];
+ xprof[3] = xprof[2];
+ yprof[3] = yprof[2] - kUpperSlideStubHi;
+ xprof[4] = upSlideAirSh->GetX(2);
+ yprof[4] = yprof[3];
+ xprof[5] = xprof[4];
+ yprof[5] = yprof[4] - kUpperSlideBlockHi;
+ xprof[6] = upSlideAirSh->GetX(5);
+ yprof[6] = yprof[5];
+ xprof[7] = xprof[6];
+ yprof[7] = yprof[0];
+
+ upSlideAluSh->DefinePolygon(8, xprof, yprof);
+ upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
+ upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
+ upSlideHoleSh->SetName("ITSupperSlideHoleShape");
+
+ zpos = upSlideAluSh->GetY(5);
+ upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
+ zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
+ - 2*kUpperSlideHoleH1);
+ upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
+ zpos += kUpperSlideHoleH3;
+ upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
+ upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
+ upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
+ zpos += kUpperSlideHoleH2;
+ upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
+ upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
+ zpos += kUpperSlideHoleH1;
+ upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);
+
+ TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
+ new TGeoRotation("",0,-90,0) );
+ upSlideHolePos->SetName("ITSupperSlideHolePos");
+ upSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
+ upSlidePinSh->SetName("ITSupperSlidePinShape");
+
+ zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
+ + kUpperSlidePinH3 - kUpperSlideBlockHi);
+ upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH3;
+ upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
+ upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
+ zpos += kUpperSlidePinH2;
+ upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
+ upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
+ zpos += kUpperSlidePinH1;
+ upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);
+
+ // The Lower Wheel Slide (0872/C/W/00-01-02-03)
+ // A mother volume of air (to avoid assembly) contains the Alluminum block
+ // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
+ // (a Xtru) and the Steel pin (a Pcon)
+ // (The wheels are approximated as part of the block itself)
+ // The Air mother volume
+ TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
+ lwSlideAirSh->SetName("ITSlowerSlideAirShape");
+
+ xprof[0] = 0;
+ yprof[0] = 0;
+ xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
+ xprof[3] = xprof[2] - kLowerSlideTotDepth;
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
+ xprof[5] = xprof[0];
+ yprof[5] = yprof[4];
+
+ lwSlideAirSh->DefinePolygon(6, xprof, yprof);
+ lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
+ lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);
+
+ // The (filled) Aluminum block: a Xtru
+ TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
+ lwSlideAluSh->SetName("ITSlowerSlideAluShape");
+
+ xprof[0] = lwSlideAirSh->GetX(0);
+ yprof[0] = lwSlideAirSh->GetY(0);
+ xprof[1] = lwSlideAirSh->GetX(1);
+ yprof[1] = lwSlideAirSh->GetY(1);
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] - kLowerSlideBlockHi;
+ xprof[3] = lwSlideAirSh->GetX(3);
+ yprof[3] = yprof[2];
+ xprof[4] = xprof[3];
+ yprof[4] = yprof[3] + kLowerSlideBlockHi;
+ xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
+ yprof[5] = yprof[4];
+ xprof[6] = xprof[5];
+ yprof[6] = lwSlideAirSh->GetY(4);
+ xprof[7] = xprof[0];
+ yprof[7] = yprof[6];
+
+ lwSlideAluSh->DefinePolygon(8, xprof, yprof);
+ lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
+ lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));
+
+ // The cylindrical hole in the block; a Pcon
+ TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
+ lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");
+
+ zpos = lwSlideAluSh->GetY(2);
+ lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
+ zpos += kLowerSlideHoleH1;
+ lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
+ lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
+ zpos = lwSlideAluSh->GetY(4);
+ lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);
+
+ TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
+ 0, 0,
+ new TGeoRotation("",0,-90,0) );
+ lwSlideHolePos->SetName("ITSlowerSlideHolePos");
+ lwSlideHolePos->RegisterYourself();
+
+ // The actual block: a CompositeShape
+ TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");
+
+ // The Aluminum nose: a Xtru
+ TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
+ lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");
+
+ xprof[0] = lwSlideAluSh->GetX(5);
+ yprof[0] = lwSlideAluSh->GetY(5);
+ xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
+ yprof[1] = yprof[0];
+ xprof[2] = xprof[1];
+ yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
+ xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
+ yprof[3] = lwSlideAluSh->GetY(6);
+ xprof[4] = xprof[0];
+ yprof[4] = yprof[3];
+
+ lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
+ lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
+ lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);
+
+ // The Steel pin in the block; a Pcon
+ TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
+ lwSlidePinSh->SetName("ITSlowerSlidePinShape");
+
+ zpos = lwSlideAirSh->GetY(2);
+ lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
+ zpos += kLowerSlidePinH2;
+ lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
+ lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
+ zpos += kLowerSlidePinH1;
+ lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);
+
+ // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
+ // to approximate arcs with polylines
+ TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<11; j++) { // The internal arc
+ xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
+ yprof[j] = kStirrC12R50*SinD(90*j/10);
+ }
+
+ xprof[11] = xprof[10] + kStirrC12TailLen;
+ yprof[11] = yprof[10];
+ xprof[12] = xprof[11];
+ yprof[12] = kStirrC12BodyHalfHi;
+ xprof[13] = xprof[12] - kStirrC12BodyLen;
+ yprof[13] = yprof[12];
+
+ xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
+ yprof[17] = kStirrC12HeadHalfHi;
+ IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
+ kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
+ xprof[16], yprof[16], xdummy, ydummy);
+ alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
+ xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
+ yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
+ xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
+ yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));
+
+ xprof[18] = xprof[17] - kStirrC12HeadLen;
+ yprof[18] = yprof[17];
+ xprof[19] = xprof[18];
+ yprof[19] = kStirrC12HeadIntHi;
+ xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
+ yprof[20] = yprof[19];
+ for (Int_t j=1; j<4; j++) {
+ xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
+ yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
+ }
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
+ xprof[24+jp] = xprof[23-jp];
+ yprof[24+jp] = -yprof[23-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
+ stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);
+
+ // The first element of the Stirrup on the Forward side (0872/C/05):
+ // a really complex Xtru (equal to part of the Muon Stirrup)
+ // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
+ TGeoXtru *stirrupC5Sh = new TGeoXtru(2);
+
+ for (Int_t j=0; j<13; j++) { // The internal arc and the tail
+ xprof[j] = stirrupC1C2Sh->GetX(j);
+ yprof[j] = stirrupC1C2Sh->GetY(j);
+ }
+
+ xprof[13] = xprof[12] - kStirrC5BodyLen;
+ yprof[13] = yprof[12];
+
+ // We did the up side, now reflex on the bottom side
+ for (Int_t jp = 0; jp < 13; jp++) {
+ xprof[14+jp] = xprof[13-jp];
+ yprof[14+jp] = -yprof[13-jp];
+ }
+
+ // Now the actual Xtru
+ stirrupC5Sh->DefinePolygon(27, xprof, yprof);
+ stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
+ stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);
+
+
+ // We have all shapes: now create the real volumes
+ TGeoMedium *medAlcoa = mgr->GetMedium("ITS_ALUMINUM$"); // To code!!!!!!
+ TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
+ TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
+ TGeoMedium *medErgal = mgr->GetMedium("ITS_ERGAL$");
+ TGeoMedium *medAisi = mgr->GetMedium("ITS_AISI304L$");
+ TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ TGeoMedium *medPlexy = mgr->GetMedium("ITS_PLEXYGLAS$");
+ TGeoMedium *medPVC = mgr->GetMedium("ITS_PVC$");
+
+
+ TGeoVolume *suppRingC2C3 = new TGeoVolume("ITSTPCsupportRingC2C3",
+ ringC2C3, medAlcoa);
+
+ suppRingC2C3->SetVisibility(kTRUE);
+ suppRingC2C3->SetLineColor(6); // Purple
+ suppRingC2C3->SetLineWidth(1);
+ suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
+ suppRingC2C3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwUpHook = new TGeoVolume("ITSTPCsupportForwUpHook",
+ forwUpHookShape, medHokotol);
+
+ forwUpHook->SetVisibility(kTRUE);
+ forwUpHook->SetLineColor(6); // Purple
+ forwUpHook->SetLineWidth(1);
+ forwUpHook->SetFillColor(forwUpHook->GetLineColor());
+ forwUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwLwHook = new TGeoVolume("ITSTPCsupportForwLwHook",
+ forwLwHookShape, medHokotol);
+
+ forwLwHook->SetVisibility(kTRUE);
+ forwLwHook->SetLineColor(6); // Purple
+ forwLwHook->SetLineWidth(1);
+ forwLwHook->SetFillColor(forwLwHook->GetLineColor());
+ forwLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearUpHook = new TGeoVolume("ITSTPCsupportRearUpHook",
+ rearUpHookShape, medHokotol);
+
+ rearUpHook->SetVisibility(kTRUE);
+ rearUpHook->SetLineColor(6); // Purple
+ rearUpHook->SetLineWidth(1);
+ rearUpHook->SetFillColor(rearUpHook->GetLineColor());
+ rearUpHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwHook = new TGeoVolume("ITSTPCsupportRearLwHook",
+ rearLwHookShape, medAnticor);
+
+ rearLwHook->SetVisibility(kTRUE);
+ rearLwHook->SetLineColor(6); // Purple
+ rearLwHook->SetLineWidth(1);
+ rearLwHook->SetFillColor(rearLwHook->GetLineColor());
+ rearLwHook->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *rearLwBrack = new TGeoVolume("ITSTPCsupportRearLwBracket",
+ rearLwBrackShape, medAnticor);
+
+ rearLwBrack->SetVisibility(kTRUE);
+ rearLwBrack->SetLineColor(6); // Purple
+ rearLwBrack->SetLineWidth(1);
+ rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
+ rearLwBrack->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebSStirrup = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
+ forwWebSStirrSh, medAnticor);
+
+ forwWebSStirrup->SetVisibility(kTRUE);
+ forwWebSStirrup->SetLineColor(6); // Purple
+ forwWebSStirrup->SetLineWidth(1);
+ forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
+ forwWebSStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr3 = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
+ forwWebTStirr3Sh, medAnticor);
+
+ forwWebTStirr3->SetVisibility(kTRUE);
+ forwWebTStirr3->SetLineColor(6); // Purple
+ forwWebTStirr3->SetLineWidth(1);
+ forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
+ forwWebTStirr3->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *forwWebTStirr4 = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
+ forwWebTStirr4Sh, medAnticor);
+
+ forwWebTStirr4->SetVisibility(kTRUE);
+ forwWebTStirr4->SetLineColor(6); // Purple
+ forwWebTStirr4->SetLineWidth(1);
+ forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
+ forwWebTStirr4->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *frWebClamp = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
+ frWebClampSh, medPlexy);
+
+ frWebClamp->SetVisibility(kTRUE);
+ frWebClamp->SetLineColor(kAzure);
+ frWebClamp->SetLineWidth(1);
+ frWebClamp->SetFillColor(frWebClamp->GetLineColor());
+ frWebClamp->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upWebStirrup = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
+ upWebStirrSh, medAnticor);
+
+ upWebStirrup->SetVisibility(kTRUE);
+ upWebStirrup->SetLineColor(6); // Purple
+ upWebStirrup->SetLineWidth(1);
+ upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
+ upWebStirrup->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upRearWebBar = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
+ upRearWebBarSh, medPlexy);
+
+ upRearWebBar->SetVisibility(kTRUE);
+ upRearWebBar->SetLineColor(kAzure);
+ upRearWebBar->SetLineWidth(1);
+ upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
+ upRearWebBar->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *webCam = new TGeoVolume("ITSTPCsupportWebcam",
+ webcamShape, medPVC);
+
+ webCam->SetVisibility(kTRUE);
+ webCam->SetLineColor(kBlack);
+ webCam->SetLineWidth(1);
+ webCam->SetFillColor(webCam->GetLineColor());
+ webCam->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlideVol = new TGeoVolume("ITSTPCsupportUpperSlide",
+ upSlideAirSh, medAir);
+
+ upSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *upSlideBlock = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
+ upSlideBlockSh, medAnticor);
+
+ upSlideBlock->SetVisibility(kTRUE);
+ upSlideBlock->SetLineColor(6); // Purple
+ upSlideBlock->SetLineWidth(1);
+ upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
+ upSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *upSlidePin = new TGeoVolume("ITSTPCsupportUpperSlidePin",
+ upSlidePinSh, medAisi);
+
+ upSlidePin->SetVisibility(kTRUE);
+ upSlidePin->SetLineColor(kGray);
+ upSlidePin->SetLineWidth(1);
+ upSlidePin->SetFillColor(upSlidePin->GetLineColor());
+ upSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideVol = new TGeoVolume("ITSTPCsupportLowerSlide",
+ lwSlideAirSh, medAir);
+
+ lwSlideVol->SetVisibility(kFALSE);
+
+ TGeoVolume *lwSlideBlock = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
+ lwSlideBlockSh, medAnticor);
+
+ lwSlideBlock->SetVisibility(kTRUE);
+ lwSlideBlock->SetLineColor(6); // Purple
+ lwSlideBlock->SetLineWidth(1);
+ lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
+ lwSlideBlock->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlideNose = new TGeoVolume("ITSTPCsupportLowerSlideNose",
+ lwSlideNoseSh, medAnticor);
+
+ lwSlideNose->SetVisibility(kTRUE);
+ lwSlideNose->SetLineColor(6); // Purple
+ lwSlideNose->SetLineWidth(1);
+ lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
+ lwSlideNose->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *lwSlidePin = new TGeoVolume("ITSTPCsupportLowerSlidePin",
+ lwSlidePinSh, medAisi);
+
+ lwSlidePin->SetVisibility(kTRUE);
+ lwSlidePin->SetLineColor(kGray);
+ lwSlidePin->SetLineWidth(1);
+ lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
+ lwSlidePin->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC1C2 = new TGeoVolume("ITSTPCsupportStirrupC1C2",
+ stirrupC1C2Sh, medErgal);
+
+ stirrC1C2->SetVisibility(kTRUE);
+ stirrC1C2->SetLineColor(6); // Purple
+ stirrC1C2->SetLineWidth(1);
+ stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
+ stirrC1C2->SetFillStyle(4000); // 0% transparent
+
+ TGeoVolume *stirrC5 = new TGeoVolume("ITSTPCsupportStirrupC5",
+ stirrupC5Sh, medErgal);
+
+ stirrC5->SetVisibility(kTRUE);
+ stirrC5->SetLineColor(6); // Purple
+ stirrC5->SetLineWidth(1);
+ stirrC5->SetFillColor(stirrC5->GetLineColor());
+ stirrC5->SetFillStyle(4000); // 0% transparent
+
+
+ // Build up the wheel slides
+ upSlideVol->AddNode(upSlideBlock,1,0);
+ upSlideVol->AddNode(upSlidePin, 1,
+ new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+ lwSlideVol->AddNode(lwSlideBlock,1,0);
+ lwSlideVol->AddNode(lwSlideNose ,1,0);
+ lwSlideVol->AddNode(lwSlidePin, 1,
+ new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
+ new TGeoRotation("",0,-90,0) ) );
+
+
+ // Finally put everything in the mother volume
+ moth->AddNode(suppRingC2C3,1,
+ new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
+ moth->AddNode(suppRingC2C3,2,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,0.) ) );
+ moth->AddNode(suppRingC2C3,3,
+ new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
+ new TGeoRotation("",0.,0.,180.) ) );
+ moth->AddNode(suppRingC2C3,4,
+ new TGeoCombiTrans( 0, 0,-kRingCZPos,
+ new TGeoRotation("",0.,180.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwUpHook,1,
+ new TGeoTranslation( 0, 0, zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwLwHook,1,
+ new TGeoCombiTrans( 0, 0, zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
+ moth->AddNode(rearUpHook,1,
+ new TGeoTranslation( 0, 0,-zpos) );
+
+ zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
+ moth->AddNode(rearLwHook,1,
+ new TGeoCombiTrans( 0, 0,-zpos,
+ new TGeoRotation("",0.,0.,180.) ) );
+
+ xpos = kRearLwHookWide/2 + kRearLwBracketThick/2;
+ ypos = -kRingCHeight;
+ moth->AddNode(rearLwBrack,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(rearLwBrack,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ xpos = kForwUpHookWide/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
+ zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
+ moth->AddNode(forwWebSStirrup,1,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+ xpos = kForwLwHookWide/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
+ moth->AddNode(forwWebSStirrup,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ xpos = kForwUpHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
+ zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
+ moth->AddNode(forwWebTStirr3,1,
+ new TGeoTranslation( xpos, ypos, zpos) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,1,
+ new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,1,
+ new TGeoTranslation( xpos, ypos,
+ zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kForwLwHookWide/2
+ + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
+ ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
+ + forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
+ moth->AddNode(forwWebTStirr4,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 180., 0., 0.) ) );
+
+ ypos -= frWebClampSh->GetZ(1);
+ moth->AddNode(frWebClamp,2,
+ new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ moth->AddNode(webCam,2,
+ new TGeoTranslation( xpos,-ypos,
+ zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );
+
+ xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
+ ypos = kRingCHeight;
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upWebStirrup,1,
+ new TGeoCombiTrans( xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upWebStirrup,2,
+ new TGeoCombiTrans(-xpos, ypos,-zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+
+ ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
+ zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
+ - upRearWebBarSh->GetDZ();
+ moth->AddNode(upRearWebBar,1,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ zpos -= upRearWebBarSh->GetDZ();
+ moth->AddNode(frWebClamp,3,
+ new TGeoCombiTrans( 0, ypos,-zpos,
+ new TGeoRotation("", 0., 90., 0.) ) );
+
+ ypos -= webcamShape->GetDY()/2;
+ zpos -= webcamShape->GetDZ();
+ moth->AddNode(webCam,3,
+ new TGeoTranslation( 0, ypos,-zpos) );
+
+ xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14);
+ zpos = kRingCZPos + kRingCThick;
+ moth->AddNode(upSlideVol,1,
+ new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,2,
+ new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,3,
+ new TGeoCombiTrans( xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+ moth->AddNode(upSlideVol,4,
+ new TGeoCombiTrans(-xpos, ypos, -zpos,
+ new TGeoRotation("", 90.,-90.,-90.) ) );
+
+ moth->AddNode(lwSlideVol,1,
+ new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,2,
+ new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,3,
+ new TGeoCombiTrans( xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+ moth->AddNode(lwSlideVol,4,
+ new TGeoCombiTrans(-xpos,-ypos,-zpos,
+ new TGeoRotation("",-90.,-90.,-90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
+ moth->AddNode(stirrC1C2,1,
+ new TGeoTranslation( xpos, 0, zpos) );
+ moth->AddNode(stirrC1C2,2,
+ new TGeoCombiTrans(-xpos, 0, zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+ xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
+ ypos = ringC2C3->GetY(14); // Slides are all at the same height
+ zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
+ moth->AddNode(upSlideVol,5,
+ new TGeoCombiTrans( xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(upSlideVol,6,
+ new TGeoCombiTrans(-xpos, ypos, zpos,
+ new TGeoRotation("",-90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,5,
+ new TGeoCombiTrans( xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+ moth->AddNode(lwSlideVol,6,
+ new TGeoCombiTrans(-xpos,-ypos, zpos,
+ new TGeoRotation("", 90.,-90., 90.) ) );
+
+ xpos = kStirrCXPos;
+ zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
+ moth->AddNode(stirrC5,1,
+ new TGeoTranslation( xpos, 0,-zpos) );
+ moth->AddNode(stirrC5,2,
+ new TGeoCombiTrans(-xpos, 0,-zpos,
+ new TGeoRotation("", 90.,-180.,-90.) ) );
+
+
+ return;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff