* provided "as is" without express or implied warranty. *
**************************************************************************/
+/* $Id$ */
//*************************************************************************
// SSD geometry, based on ROOT geometrical modeler
//*************************************************************************
#include "TMath.h"
#include "TGeoVolume.h"
-#include "TGeoMedium.h"
#include "TGeoMatrix.h"
#include <TGeoManager.h>
-#include "AliITSv11GeometrySSD.h"
#include "TVector3.h"
#include "TGeoArb8.h"
#include "TList.h"
#include "TGeoCompositeShape.h"
#include "TGeoTube.h"
#include "TGeoBBox.h"
-#include "TGeoTrd1.h"
-#include <iostream>
-using namespace std;
+#include "TGeoXtru.h"
+#include "TGeoTorus.h"
+#include "TGeoPgon.h"
+#include "TRotation.h"
+#include "AliITSv11GeometrySSD.h"
+/////////////////////////////////////////////////////////////////////////////////
+// Names of the Sensitive Volumes of Layer 5 and Layer 6
+/////////////////////////////////////////////////////////////////////////////////
+const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
+const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
/////////////////////////////////////////////////////////////////////////////////
//Parameters for SSD Geometry
/////////////////////////////////////////////////////////////////////////////////
// Layer5 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
-const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0;
-const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0;
-const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Layer6 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
-const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0;
-const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0;
-const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
-const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
+const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Stiffener (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
-const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315;
-const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400;
-const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400;
-const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32, 0.33};
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16;
-const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
+const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
+ {44.32*fgkmm, 0.33*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
0.25*fgkSSDStiffenerHeight;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Cooling Block (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
- {1.950, 0.240, 0.300};
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
+ {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
- {1.000, 0.120};
+ {1.000*fgkmm, 0.120*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
- {1.900, 0.400};
+ {1.900*fgkmm, 0.400*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
- 1.500;
+ 1.500*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
- 0.300;
+ 0.300*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// SSD Sensor (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
- "SSDSensorSensitiveVol";
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000;
+ "SSDSensorSensitiveVol";
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
- fgkSSDSensorLength-39.1;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.;
+ fgkSSDSensorLength-39.1*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Flex (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
- {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
- +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
- 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
- +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000,
- 9.500, 10.000};
+ {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+ + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+ 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+ + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
+ - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
- { 9.340, 5.380};
+ { 9.340*fgkmm, 5.380*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
- { 0.030, 0.020};
+ { 0.030*fgkmm, 0.020*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
-const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430;
-const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000;
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
- {3.30,4.12,4.22,1.70,0.75,7.18};
+ {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
- {15.03,23.48,12.28};
+ {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
/////////////////////////////////////////////////////////////////////////////////
// SSD Ladder Cable (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5;
-const Double_t AliITSv11GeometrySSD::fgkSSDEndLadderCableLength = 50.000; /////to be modified
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// SSD Module (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
- { 1.000, 3.900};
+ { 1.000*fgkmm, 3.900*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
- 45.600;
+ 45.600*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
- 5.075;
+ 5.075*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Sensor Support (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
- 5.800;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
+ 5.800*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
- 2.000;
+ 2.000*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
- { 4.620, 5.180};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
- { 0.450, 0.450};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition =
- 0.5*(fgkSSDModuleSensorSupportDistance
- + fgkSSDSensorSideSupportThickness[0])
- - fgkSSDSensorSideSupportLength;
+ { 4.620*fgkmm, 5.180*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
+ { 0.450*fgkmm, 0.450*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
+ = 0.5 * (fgkSSDModuleSensorSupportDistance
+ + fgkSSDSensorSideSupportThickness[0])
+ - fgkSSDSensorSideSupportLength;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
- 5.250;
+ 5.250*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
- 1.680;
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2] =
- {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
- fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
-const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
- {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
+ 1.680*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
+ = {fgkSSDSensorSideSupportHeight[0]
+ + fgkSSDSensorSideSupportThickness[0],
+ fgkSSDSensorSideSupportHeight[1]
+ + fgkSSDSensorSideSupportThickness[1]};
+const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
+ = {fgkSSDSensorSideSupportThickness[0],
+ fgkSSDSensorSideSupportThickness[1]};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
- 19.000;
+ 19.000*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Chip Cables (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
- {73.12/fgkSSDChipNumber,fgkSSDChipLength+2.*0.19};
+ {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
- { 0.014, 0.010, fgkSSDModuleCoolingBlockToSensor
- - (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
- - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
- - fgkSSDChipHeight-fgkSSDSensorHeight,
- fgkSSDModuleCoolingBlockToSensor
- - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
- - fgkSSDChipHeight-fgkSSDSensorHeight};
+ { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
+ - (fgkSSDSensorSideSupportHeight[1]
+ - fgkSSDSensorSideSupportHeight[0])
+ - fgkSSDCoolingBlockHoleCenter
+ - fgkSSDStiffenerHeight
+ - fgkSSDChipHeight-fgkSSDSensorHeight,
+ fgkSSDModuleCoolingBlockToSensor
+ - fgkSSDCoolingBlockHoleCenter
+ - fgkSSDStiffenerHeight
+ - fgkSSDChipHeight-fgkSSDSensorHeight};
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
- { 11.000, 0.800, 0.600};
+ { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
/////////////////////////////////////////////////////////////////////////////////
// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
- 3.820;
+ 3.820*fgkmm;
//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
// 3.780;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
- fgkSSDSensorLength-fgkSSDSensorOverlap;
+ fgkSSDSensorLength-fgkSSDSensorOverlap;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
- { 0.86, 0.30};
+ { 0.86*fgkmm, 0.30*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
- { 30.00, 90.00};
+ { 30.00, 90.00};
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
- 1.78;
+ 1.78*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength =
- fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle =
- 60.00;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
+ = fgkSSDModuleSensorSupportDistance
+ - 2. * fgkCarbonFiberJunctionToSensorSupport;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
- { 0.751, 0.482};
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
- 1.630;
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =
- 0.950;
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength =
- fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
- / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
-const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength =
- 0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
- - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
+ { 0.751*fgkmm, 0.482*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
+ 1.630*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
+ = fgkCarbonFiberTriangleLength
+ - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
+ / TMath::Cos(fgkCarbonFiberTriangleAngle
+ * TMath::DegToRad());
+const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
+ = 0.5*(fgkCarbonFiberJunctionWidth
+ - fgkCarbonFiberSupportWidth)
+ - fgkCarbonFiberSupportTopEdgeDist[0]
+ - fgkCarbonFiberSupportWidth;
/////////////////////////////////////////////////////////////////////////////////
// Carbon Fiber Lower Support Parameters (lengths are in mm)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
- = 0.950;
+ = 0.950*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
- = 1.600;
+ = 1.600*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
- = 0.830;
+ = 0.830*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
= 0.5*fgkCarbonFiberSupportWidth;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
- = fgkCarbonFiberJunctionWidth
- - 2.*(fgkCarbonFiberLowerSupportWidth
- + fgkCarbonFiberLowerSupportVolumeSeparation);
+ = fgkCarbonFiberJunctionWidth
+ - 2. * (fgkCarbonFiberLowerSupportWidth
+ + fgkCarbonFiberLowerSupportVolumeSeparation);
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
- = {fgkCarbonFiberLowerSupportWidth
- + fgkCarbonFiberLowerSupportVolumeSeparation,
- fgkCarbonFiberLowerSupportWidth
- + fgkCarbonFiberLowerSupportVolumeSeparation
- + fgkCarbonFiberLowerSupportTransverseWidth};
+ = {fgkCarbonFiberLowerSupportWidth
+ + fgkCarbonFiberLowerSupportVolumeSeparation,
+ fgkCarbonFiberLowerSupportWidth
+ + fgkCarbonFiberLowerSupportVolumeSeparation
+ + fgkCarbonFiberLowerSupportTransverseWidth};
/////////////////////////////////////////////////////////////////////////////////
// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
- {0.5*(fgkSSDLay5LadderLength
- -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
- -fgkCarbonFiberLowerSupportWidth),
- 0.5*(fgkSSDLay5LadderLength
- -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
- +fgkCarbonFiberLowerSupportWidth)};
+ {0.5 * (fgkSSDLay5LadderLength
+ - fgkSSDLay5SensorsNumber
+ * fgkCarbonFiberJunctionWidth
+ - fgkCarbonFiberLowerSupportWidth),
+ 0.5 * (fgkSSDLay5LadderLength
+ - fgkSSDLay5SensorsNumber
+ * fgkCarbonFiberJunctionWidth
+ + fgkCarbonFiberLowerSupportWidth)};
const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
- {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4,
- fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6};
+ {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
- {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50,
- fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50};
+ {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
+ {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
/////////////////////////////////////////////////////////////////////////////////
// Cooling Tube Support (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
= fgkSSDCoolingBlockHoleRadius[0];
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
- fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70;
+ fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
+ 11.70*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Cooling Tube (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax =
- fgkCoolingTubeSupportRmin;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
fgkCarbonFiberJunctionWidth;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
- fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
-//const Double_t AliITSv11GeometrySSD_ct::fgkCoolingTubeLength = 39.1;
+ fgkSSDModuleSensorSupportDistance
+ + fgkSSDCoolingBlockLength;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
- { 60.0, 42.2, 34.0};
+ { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
- { 4.0, 8.0, 5.0, 0.2};
+ { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
- 20.0;
+ 20.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
- 40.0;
+ 40.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
- 2.5;
+ 2.5*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
- { 56.0, 12.0};
+ { 56.0*fgkmm, 12.0*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
- { 5.0, 2.9};
+ { 5.0*fgkmm, 2.9*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
- 1.0;
+ 1.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
- 6.0;
+ 6.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
- 4.0;
+ 4.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
- { 1.5,fgkSSDMountingBlockScrewHoleEdge/6.};
-/////////////////////////////////////////////////////////////////////////////////
-AliITSv11GeometrySSD::AliITSv11GeometrySSD(){
- /////////////////////////////////
- // Standard Default Constructor
- /////////////////////////////////
- // Initializing display colors
- //////////////////////////////
- fColorCarbonFiber = 4;
- fColorRyton = 5;
- fColorPhynox = 5;
- fColorSilicon = 3;
- fColorAl = 7;
- fColorKapton = 6;
- fColorPolyhamide = 5;
- fColorStiffener = 9;
- fColorEpoxy = 30;
- CreateMaterials();
-}
+ { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
/////////////////////////////////////////////////////////////////////////////////
-// Setting the transformation Matrices
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
- ////////////////////////////////////////////////////////
- //Translation Parameters SSDSensorSupportAssembly:
- ////////////////////////////////////////////////////////
- const Double_t SSDSensorSupportTransX[3] = {-0.5*fgkSSDSensorSideSupportWidth,
- 0.5*fgkSSDSensorSideSupportWidth,
- 0.5*fgkSSDSensorCenterSupportThickness[0]
- - fgkSSDSensorCenterSupportPosition};
- const Double_t SSDSensorSupportTransY[3] =
- {0.5*fgkSSDSensorSideSupportThickness[0],
- -0.5*fgkSSDSensorSideSupportThickness[0]
- -fgkSSDModuleSensorSupportDistance,
- 0.5*fgkSSDSensorCenterSupportWidth
- -0.5*fgkSSDModuleSensorSupportDistance};
- const Double_t SSDSensorSupportTransZ[3] = {0.,0.,
- fgkSSDSensorCenterSupportThickness[0]};
- ////////////////////////////////////////////////////////
- //Rotational Parameters SSDSensorSupportAssembly:
- ////////////////////////////////////////////////////////
- const Double_t SSDSensorSupportRotPhi[3] = { 0., 180., 270.};
- const Double_t SSDSensorSupportRotTheta[3] = { 90., 90., 90.};
- const Double_t SSDSensorSupportRotPsi[3] = {- 90.,- 90.,- 90.};
- ////////////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
- ////////////////////////////////////////////////////////////////
- char SSDSensorSupportCombiTransName[40];
- char SSDSensorSupportRotName[40];
- TGeoCombiTrans *SSDSensorSupportLocalMatrix[fgkSSDSensorSupportCombiTransNumber];
- for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){
- sprintf(SSDSensorSupportCombiTransName,"SSDSensorSupportCombiTrans%i",i);
- sprintf(SSDSensorSupportRotName,"SSDSensorSupportRot%i",i);
- SSDSensorSupportLocalMatrix[i] =
- new TGeoCombiTrans(SSDSensorSupportCombiTransName,
- SSDSensorSupportTransX[i],
- SSDSensorSupportTransY[i],
- SSDSensorSupportTransZ[i],
- new TGeoRotation(SSDSensorSupportRotName,
- SSDSensorSupportRotPhi[i],
- SSDSensorSupportRotTheta[i],
- SSDSensorSupportRotPsi[i]));
- SSDSensorSupportCombiTransMatrix[i] = SSDSensorSupportLocalMatrix[i];
- }
-}
+// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
-/////////////////////////////////////////////////////////////////////////////////
-//Translation Parameters SSDModuleAssembly:
-////////////////////////////////////////////////////////
- const Double_t SSDModuleTransX[7] = {0.5*fgkSSDStiffenerLength,
- 0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
- - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
- * fgkSSDChipSeparationLength)),
- - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
- 0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
- - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
- 0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
- - fgkSSDCoolingBlockLength,
- 0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
- + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
- 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
- +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)};
- const Double_t SSDModuleTransY[7] = {0.5*fgkSSDStiffenerWidth,
- 0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
- - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
- - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
- fgkSSDStiffenerWidth,
- 0.,
- fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - fgkSSDStiffenerWidth
- + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
- fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - fgkSSDStiffenerWidth};
- const Double_t SSDModuleTransZ[7] = {0.5*fgkSSDStiffenerHeight,
- - 0.5*fgkSSDChipHeight,
- 0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
- - SSDChipCablesHeigth,
- - 0.5*fgkSSDFlexHeight[0],
- fgkSSDStiffenerHeight,
- - fgkSSDChipHeight,
- - 0.5*fgkSSDChipHeight};
- ////////////////////////////////////////////////////////
- //Rotational Parameters SSDModuleAssembly:
- ////////////////////////////////////////////////////////
- const Double_t SSDModuleRotPhi[7] = { 0., 0., 90., 0., 0., 90., 180.};
- const Double_t SSDModuleRotTheta[7] = { 0., 0., 0., 0., 0., 0., 0.};
- const Double_t SSDModuleRotPsi[7] = { 0., 0., 0., 0., 0., 0., 0.};
- ////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of SSDModuleAssembly:
- ////////////////////////////////////////////////////////
- const char* SSDModuleCombiTransName[7] = {"SSDStiffenerCombiTrans",
- "SSDChipCombiTrans",
- "SSDSensorCombiTrans",
- "SSDFlex0CombiTrans",
- "SSDCoolingBlockCombiTrans",
- "SSDChipCablesCombiTrans",
- "SSDFlex1CombiTrans"};
- const char* SSDModuleRotName[7] = {"SSDStiffenerRotName",
- "SSDChipRotName",
- "SSDSensorRotName",
- "SSDFlex0RotName",
- "SSDCoolingBlockRotName",
- "SSDChipCablesRotName",
- "SSDFlex1RotName"};
- TGeoCombiTrans *SSDModuleLocalMatrix[fgkSSDModuleCombiTransNumber];
- for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
- SSDModuleLocalMatrix[i] =
- new TGeoCombiTrans(SSDModuleCombiTransName[i],
- SSDModuleTransX[i],
- SSDModuleTransY[i],
- SSDModuleTransZ[i],
- new TGeoRotation(SSDModuleRotName[i],
- SSDModuleRotPhi[i],
- SSDModuleRotTheta[i],
- SSDModuleRotPsi[i]));
- SSDModuleCombiTransMatrix[i] = SSDModuleLocalMatrix[i];
- }
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
+ - fgkSSDMountingBlockHeight[1]
+ + 0.5*fgkCoolingTubeSupportHeight
+ + fgkSSDModuleCoolingBlockToSensor
+ - fgkMountingBlockSupportDownHeight,
+ fgkSSDLay6RadiusMin
+ - fgkSSDMountingBlockHeight[1]
+ + 0.5*fgkCoolingTubeSupportHeight
+ + fgkSSDModuleCoolingBlockToSensor
+ - fgkMountingBlockSupportDownHeight};
+const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
+ - fgkSSDMountingBlockHeight[1]
+ + 0.5*fgkCoolingTubeSupportHeight
+ + fgkSSDModuleCoolingBlockToSensor
+ - fgkMountingBlockSupportRadius[0],
+ fgkSSDLay6RadiusMax
+ - fgkSSDMountingBlockHeight[1]
+ + 0.5*fgkCoolingTubeSupportHeight
+ + fgkSSDModuleCoolingBlockToSensor
+ - fgkMountingBlockSupportRadius[1]};
+const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
+const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
+ {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
+ {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
+ {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
+ {10.5*fgkmm,9.25*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
+ {182.3,177.9,84.4,70.0,35.0};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
+ {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
+ 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
+ 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
+ 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
+ {62.0*fgkmm,21.87*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
+ {47.1*fgkmm,0.35*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
+ 1.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
+ {43.5*fgkmm, 0.70*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
+ 0.15*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
+ 19.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
+ {4.80*fgkmm,1.1*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
+ {3.3*fgkmm,1.10*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
+ 2.1*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
+ {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
+ {1.9*fgkmm,0.15*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
+ 19*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
+ 1.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
+ 3.6*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
+ 61.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
+ 5.97*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
+ {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
+ 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
+ {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
+ 1.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
+ = 0.15*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
+ 20.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
+const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
+/////////////////////////////////////////////////////////////////////////////////
+// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
+/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
+/////////////////////////////////////////////////////////////////////////////////
+ClassImp(AliITSv11GeometrySSD)
+/////////////////////////////////////////////////////////////////////////////////
+AliITSv11GeometrySSD::AliITSv11GeometrySSD():
+ AliITSv11Geometry(),
+ fSSDChipMedium(),
+ fSSDChipGlueMedium(),
+ fSSDStiffenerMedium(),
+ fSSDStiffenerConnectorMedium(),
+ fSSDStiffener0603CapacitorMedium(),
+ fSSDStiffener1812CapacitorMedium(),
+ fSSDStiffenerHybridWireMedium(),
+ fSSDKaptonFlexMedium(),
+ fSSDAlTraceFlexMedium(),
+ fSSDAlTraceLadderCableMedium(),
+ fSSDKaptonLadderCableMedium(),
+ fSSDKaptonChipCableMedium(),
+ fSSDAlTraceChipCableMedium(),
+ fSSDAlCoolBlockMedium(),
+ fSSDSensorMedium(),
+ fSSDSensorSupportMedium(),
+ fSSDCarbonFiberMedium(),
+ fSSDTubeHolderMedium(),
+ fSSDCoolingTubeWater(),
+ fSSDCoolingTubePhynox(),
+ fSSDSupportRingAl(),
+ fSSDMountingBlockMedium(),
+ fSSDAir(),
+ fCreateMaterials(kFALSE),
+ fTransformationMatrices(kFALSE),
+ fBasicObjects(kFALSE),
+ fcarbonfiberjunction(),
+ fcoolingtubesupport(),
+ fhybridmatrix(),
+ fssdcoolingblocksystem(),
+ fcoolingblocksystematrix(),
+ fssdstiffenerflex(),
+ fssdendflex(),
+ fendladdercoolingtubesupportmatrix(),
+ fendladdermountingblock(),
+ fendladdermountingblockclip(),
+ fSSDSensor5(),
+ fSSDSensor6(),
+ fSSDLayer5(),
+ fSSDLayer6(),
+ fMotherVol(),
+ fLay5LadderSupportRing(),
+ fLay6LadderSupportRing(),
+ fgkEndCapSupportSystem(),
+ fColorCarbonFiber(4),
+ fColorRyton(5),
+ fColorPhynox(14),
+ fColorSilicon(3),
+ fColorAl(38),
+ fColorKapton(6),
+ fColorPolyhamide(5),
+ fColorStiffener(9),
+ fColorEpoxy(30),
+ fColorWater(7),
+ fColorG10(41)
+{
+ ////////////////////////
+ // Standard constructor
+ ////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
-/////////////////////////////////////////////////////////////////////////////////
- //Translation Parameters CarbonFiberJunction:
- ////////////////////////////////////////////////////////
- const Double_t CarbonFiberJunctionTransX[3] =
- { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
- * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
- const Double_t CarbonFiberJunctionTransY[3] =
- { 0.0, 0.0,fgkCarbonFiberTriangleLength
- * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
- const Double_t CarbonFiberJunctionTransZ[3] = { 0.0, 0.0, 0.0};
- ////////////////////////////////////////////////////////
- //Rotational Parameters CarbonFiberJunction:
- ////////////////////////////////////////////////////////
- const Double_t CarbonFiberJunctionRotPhi[3] = { 0., 120., 240.};
- const Double_t CarbonFiberJunctionRotTheta[3] = { 0., 0., 0.};
- const Double_t CarbonFiberJunctionRotPsi[3] = { 0., 0., 0.};
- ///////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of CarbonFiberJunction:
- ///////////////////////////////////////////////////////////
- char CarbonFiberJunctionCombiTransName[40];
- char CarbonFiberJunctionRotName[40];
- TGeoCombiTrans *CarbonFiberJunctionLocalMatrix[fgkCarbonFiberJunctionCombiTransNumber];
- for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
- sprintf(CarbonFiberJunctionCombiTransName,"CarbonFiberJunctionCombiTrans%i",i);
- sprintf(CarbonFiberJunctionRotName,"CarbonFiberJunctionRot%i",i);
- CarbonFiberJunctionLocalMatrix[i] =
- new TGeoCombiTrans(CarbonFiberJunctionCombiTransName,
- CarbonFiberJunctionTransX[i],
- CarbonFiberJunctionTransY[i],
- CarbonFiberJunctionTransZ[i],
- new TGeoRotation(CarbonFiberJunctionRotName,
- CarbonFiberJunctionRotPhi[i],
- CarbonFiberJunctionRotTheta[i],
- CarbonFiberJunctionRotPsi[i]));
- CarbonFiberJunctionCombiTransMatrix[i] = CarbonFiberJunctionLocalMatrix[i];
- }
+AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
+ AliITSv11Geometry(s.GetDebug()),
+ fSSDChipMedium(s.fSSDChipMedium),
+ fSSDChipGlueMedium(s.fSSDChipGlueMedium),
+ fSSDStiffenerMedium(s.fSSDStiffenerMedium),
+ fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
+ fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
+ fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
+ fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
+ fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
+ fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
+ fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
+ fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
+ fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
+ fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
+ fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
+ fSSDSensorMedium(s.fSSDSensorMedium),
+ fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
+ fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
+ fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
+ fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
+ fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
+ fSSDSupportRingAl(s.fSSDSupportRingAl),
+ fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
+ fSSDAir(s.fSSDAir),
+ fCreateMaterials(s.fCreateMaterials),
+ fTransformationMatrices(s.fTransformationMatrices),
+ fBasicObjects(s.fBasicObjects),
+ fcarbonfiberjunction(s.fcarbonfiberjunction),
+ fcoolingtubesupport(s.fcoolingtubesupport),
+ fhybridmatrix(s.fhybridmatrix),
+ fssdcoolingblocksystem(s.fssdcoolingblocksystem),
+ fcoolingblocksystematrix(s.fcoolingblocksystematrix),
+ fssdstiffenerflex(s.fssdstiffenerflex),
+ fssdendflex(s.fssdendflex),
+ fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
+ fendladdermountingblock(s.fendladdermountingblock),
+ fendladdermountingblockclip(s.fendladdermountingblockclip),
+ fSSDSensor5(s.fSSDSensor5),
+ fSSDSensor6(s.fSSDSensor6),
+ fSSDLayer5(s.fSSDLayer5),
+ fSSDLayer6(s.fSSDLayer6),
+ fMotherVol(s.fMotherVol),
+ fLay5LadderSupportRing(s.fLay5LadderSupportRing),
+ fLay6LadderSupportRing(s.fLay6LadderSupportRing),
+ fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
+ fColorCarbonFiber(s.fColorCarbonFiber),
+ fColorRyton(s.fColorRyton),
+ fColorPhynox(s.fColorPhynox),
+ fColorSilicon(s.fColorSilicon),
+ fColorAl(s.fColorAl),
+ fColorKapton(s.fColorKapton),
+ fColorPolyhamide(s.fColorPolyhamide),
+ fColorStiffener(s.fColorStiffener),
+ fColorEpoxy(s.fColorEpoxy),
+ fColorWater(s.fColorWater),
+ fColorG10(s.fColorG10)
+{
+ ////////////////////////
+ // Copy Constructor
+ ////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
-/////////////////////////////////////////////////////////////////////////////////
- //Translation Parameters EndLadderCarbonFiberJunction:
- ////////////////////////////////////////////////////////
- const Double_t EndLadderCarbonFiberJunctionTransX[3] =
- { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
- * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
- const Double_t EndLadderCarbonFiberJunctionTransY[3] =
- { 0.0, 0.0,fgkCarbonFiberTriangleLength
- * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
- const Double_t EndLadderCarbonFiberJunctionTransZ[3] = { 0.0, 0.0,
- 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
- -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
- ////////////////////////////////////////////////////////
- //Rotational Parameters EndLadderCarbonFiberJunction:
- ////////////////////////////////////////////////////////
- const Double_t EndLadderCarbonFiberJunctionRotPhi[3] = { 0., 120., 240.};
- const Double_t EndLadderCarbonFiberJunctionRotTheta[3] = { 0., 0., 0.};
- const Double_t EndLadderCarbonFiberJunctionRotPsi[3] = { 0., 0., 0.};
- ///////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of CarbonFiberJunction:
- ///////////////////////////////////////////////////////////
- char EndLadderCarbonFiberJunctionCombiTransName[40];
- char EndLadderCarbonFiberJunctionRotName[40];
- TGeoCombiTrans *EndLadderCarbonFiberJunctionLocalMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
- for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
- sprintf(EndLadderCarbonFiberJunctionCombiTransName,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
- sprintf(EndLadderCarbonFiberJunctionRotName,"EndLadderCarbonFiberJunctionRot%i",i);
- EndLadderCarbonFiberJunctionLocalMatrix[i] =
- new TGeoCombiTrans(EndLadderCarbonFiberJunctionCombiTransName,
- EndLadderCarbonFiberJunctionTransX[i],
- EndLadderCarbonFiberJunctionTransY[i],
- EndLadderCarbonFiberJunctionTransZ[i],
- new TGeoRotation(EndLadderCarbonFiberJunctionRotName,
- EndLadderCarbonFiberJunctionRotPhi[i],
- EndLadderCarbonFiberJunctionRotTheta[i],
- EndLadderCarbonFiberJunctionRotPsi[i]));
- EndLadderCarbonFiberJunctionCombiTransMatrix[i] =
- EndLadderCarbonFiberJunctionLocalMatrix[i];
- }
+AliITSv11GeometrySSD& AliITSv11GeometrySSD::
+operator=(const AliITSv11GeometrySSD &s){
+ ////////////////////////
+ // Assignment operator
+ ////////////////////////
+ this->~AliITSv11GeometrySSD();
+ new(this) AliITSv11GeometrySSD(s);
+ return *this;
+/*
+ if(&s == this) return *this;
+ fMotherVol = s.fMotherVol;
+ return *this;
+ */
}
-////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
-/////////////////////////////////////////////////////////////////////////////////
- //Translation Parameters CarbonFiberAssembly:
- ////////////////////////////////////////////////////////
- const Double_t CarbonFiberAssemblyTransX[3] = { 0.0, 0.0, 0.0};
- const Double_t CarbonFiberAssemblyTransY[3] =
- { 0.5*fgkCarbonFiberJunctionWidth, 0.0,
- fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
- - fgkCarbonFiberLowerSupportVolumePosition[0]
- - fgkCarbonFiberLowerSupportVolumePosition[1]};
- const Double_t CarbonFiberAssemblyTransZ[3] =
- { 0.0, 0.0,- 0.5*fgkCarbonFiberLowerSupportHeight};
- ////////////////////////////////////////////////////////
- //Rotational Parameters CarbonFiberAssembly:
- ////////////////////////////////////////////////////////
- const Double_t CarbonFiberAssemblyRotPhi[3] = { 0., 90., 0.};
- const Double_t CarbonFiberAssemblyRotTheta[3] = { 90.,
- -fgkCarbonFiberTriangleAngle, 0.};
- const Double_t CarbonFiberAssemblyRotPsi[3] = { 0.,- 90., 0.};
- ///////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of CarbonFiberAssembly:
- ///////////////////////////////////////////////////////////
- char CarbonFiberAssemblyCombiTransName[30];
- char CarbonFiberAssemblyRotName[30];
- TGeoCombiTrans *CarbonFiberAssemblyLocalMatrix[fgkCarbonFiberAssemblyCombiTransNumber];
- for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
- sprintf(CarbonFiberAssemblyCombiTransName,"CarbonFiberAssemblyCombiTrans%i",i);
- sprintf(CarbonFiberAssemblyRotName,"CarbonFiberAssemblyRot%i",i);
- CarbonFiberAssemblyLocalMatrix[i] =
- new TGeoCombiTrans(CarbonFiberAssemblyCombiTransName,
- CarbonFiberAssemblyTransX[i],
- CarbonFiberAssemblyTransY[i],
- CarbonFiberAssemblyTransZ[i],
- new TGeoRotation(CarbonFiberAssemblyRotName,
- CarbonFiberAssemblyRotPhi[i],
- CarbonFiberAssemblyRotTheta[i],
- CarbonFiberAssemblyRotPsi[i]));
- CarbonFiberAssemblyCombiTransMatrix[i] = CarbonFiberAssemblyLocalMatrix[i];
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::CreateTransformationMatrices(){
+ ///////////////////////////////////////////////////////////////////////
+ // Method generating the trasformation matrix for the whole SSD Geometry
+ ///////////////////////////////////////////////////////////////////////
+ // Setting some variables for Carbon Fiber Supportmatrix creation
+ //////////////////////////////////////////////////////////////////////
+ Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
+ * CosD(fgkCarbonFiberJunctionAngle[0]);
+ Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
+ + fgkCarbonFiberSupportTopEdgeDist[0]
+ + fgkCarbonFiberSupportWidth);
+ Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
+ * TanD(fgkCarbonFiberJunctionAngle[0]);
+ TGeoRotation* carbonfiberot[3];
+ for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
+ carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
+ carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
+ carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
+ Double_t transvector[3] = {fgkCarbonFiberTriangleLength
+ * CosD(fgkCarbonFiberTriangleAngle),0.,
+ - fgkCarbonFiberTriangleLength
+ * SinD(fgkCarbonFiberTriangleAngle)};
+ ///////////////////////////////////////////
+ //Setting Local Translations and Rotations:
+ ///////////////////////////////////////////
+ TGeoCombiTrans* localcarbonfibersupportmatrix[3];
+ localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
+ 0.5*carbonfibersupportheight,NULL);
+ localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
+ 2.*symmetryplaneposition+transvector[1],
+ transvector[2], carbonfiberot[2]);
+ localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Support Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
+ for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
+ fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
+ for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
+ fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
+ }
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Junction Transformation
+ /////////////////////////////////////////////////////////////
+ const Int_t kcarbonfiberjunctionmatrixnumber = 2;
+ TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
+ TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
+ TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
+ for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
+ localcarbonfiberjunctionmatrix[i] =
+ new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
+ localcarbonfiberjunctionrot[i] =
+ new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
+ localcarbonfiberjunctiontrans[i] =
+ new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
}
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
- ////////////////////////////////////////////////////////
- //Translation Parameters CoolingTubeSupport:
- ////////////////////////////////////////////////////////
- Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
+ ///////////////////////
+ // Setting Translations
+ ///////////////////////
+ localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
+ localcarbonfiberjunctiontrans[1][0] =
+ new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
+ localcarbonfiberjunctiontrans[2][0] =
+ new TGeoTranslation(fgkCarbonFiberTriangleLength
+ * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
+ fgkCarbonFiberTriangleLength
+ * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
+ localcarbonfiberjunctiontrans[0][1] =
+ new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
+ localcarbonfiberjunctiontrans[1][1] =
+ new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
+ localcarbonfiberjunctiontrans[2][1] =
+ new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
+ ////////////////////
+ // Setting Rotations
+ ////////////////////
+ for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
+ for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
+ localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
+ for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
+ localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
+ localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
+ localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
+ localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
+ ////////////////////////////////////////
+ // Setting Carbon Fiber Junction matrix
+ ////////////////////////////////////////
+ for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
+ fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
+ for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
+ localcarbonfiberjunctionmatrix[i][j] =
+ new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
+ *localcarbonfiberjunctionrot[i][j]);
+ fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Lower Support Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoTranslation* localcarbonfiberlowersupportrans[2];
+ localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
+ fgkCarbonFiberLowerSupportVolumePosition[1]
+ + fgkCarbonFiberLowerSupportVolumePosition[0],
+ 0.0);
+ localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
+ fgkCarbonFiberJunctionWidth
+ - fgkCarbonFiberLowerSupportWidth
+ - fgkCarbonFiberLowerSupportVolumePosition[0]
+ - fgkCarbonFiberLowerSupportVolumePosition[1],
+ - 0.5*fgkCarbonFiberLowerSupportHeight);
+ localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
+ fcarbonfiberlowersupportrans[0] =
+ new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
+ fcarbonfiberlowersupportrans[1] =
+ new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
+ /////////////////////////////////////////////////////////////
+ // SSD Sensor Support Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t kssdsensorsupportmatrixnumber = 3;
+ TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
+ TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
+ TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
+ for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
+ localssdsensorsupportmatrix[i] =
+ new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
+ localssdsensorsupportrot[i] =
+ new TGeoRotation*[kssdsensorsupportmatrixnumber];
+ localssdsensorsupportrans[i] =
+ new TGeoTranslation*[kssdsensorsupportmatrixnumber];
+ }
+ ///////////////////////
+ // Setting Translations
+ ///////////////////////
+ localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
+ 0.5*fgkSSDSensorSideSupportWidth,
+ 0.0);
+ localssdsensorsupportrans[1][0] =
+ new TGeoTranslation(*localssdsensorsupportrans[0][0]);
+ localssdsensorsupportrans[2][0] =
+ new TGeoTranslation(*localssdsensorsupportrans[0][0]);
+ localssdsensorsupportrans[0][1] =
+ new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
+ 0.5*fgkSSDSensorSideSupportThickness[0],
+ 0.0);
+ localssdsensorsupportrans[1][1] =
+ new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
+ - 0.5*fgkSSDSensorSideSupportThickness[0]
+ - fgkSSDModuleSensorSupportDistance,
+ 0.0);
+ localssdsensorsupportrans[2][1] =
+ new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
+ - fgkSSDSensorCenterSupportPosition,
+ 0.5*fgkSSDSensorCenterSupportWidth
+ - 0.5*fgkSSDModuleSensorSupportDistance,
+ fgkSSDSensorCenterSupportThickness[0]);
+ localssdsensorsupportrans[0][2] =
+ new TGeoTranslation(fgkCarbonFiberTriangleLength
+ + fgkCarbonFiberJunctionToSensorSupport,
+ fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])
+ - fgkSSDSensorCenterSupportPosition,
+ 0.0);
+ localssdsensorsupportrans[1][2] =
+ new TGeoTranslation(*localssdsensorsupportrans[0][2]);
+ localssdsensorsupportrans[2][2] =
+ new TGeoTranslation(*localssdsensorsupportrans[0][2]);
+ ////////////////////
+ // Setting Rotations
+ ////////////////////
+ for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
+ for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
+ localssdsensorsupportrot[i][j] = new TGeoRotation();
+ for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
+ localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
+ localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
+ }
+ localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
+ localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
+ localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
+ ////////////////////////////////////////
+ // SSD Sensor Support matrix
+ ////////////////////////////////////////
+ for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
+ fssdsensorsupportmatrix[i] = new TGeoHMatrix();
+ for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
+ localssdsensorsupportmatrix[i][j] =
+ new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
+ *localssdsensorsupportrot[i][j]);
+ fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Tube Support Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t kcoolingtubesupportmatrixnumber = 2;
+ TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
+ TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
+ TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
+ Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
/fgkCoolingTubeSupportRmax);
- const Double_t CoolingTubeSupportTransX[2] =
- {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(Phi)
+ localcoolingtubesupportrans[0] =
+ new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
+ 2.*(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(Phi)))
+ - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
+ fgkCarbonFiberTriangleLength
- - 2.0*fgkCarbonFiberJunctionLength};
- const Double_t CoolingTubeSupportTransY[2] = { 0.0, 0.0};
- const Double_t CoolingTubeSupportTransZ[2] = { 0.0, 0.0};
- ////////////////////////////////////////////////////////
- //Rotational Parameters CoolingTubeSupport:
- ////////////////////////////////////////////////////////
- const Double_t CoolingTubeSupportRotPhi[2] = { 0., 180.};
- const Double_t CoolingTubeSupportRotTheta[2] = { 0., 0.};
- const Double_t CoolingTubeSupportRotPsi[2] = { 0., 0.};
- ///////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of CarbonFiberJunction:
- ///////////////////////////////////////////////////////////
- char CoolingTubeSupportCombiTransName[40];
- char CoolingTubeSupportRotName[40];
- TGeoCombiTrans *CoolingTubeSupportLocalMatrix[fgkCoolingTubeSupportCombiTransNumber];
- for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
- sprintf(CoolingTubeSupportCombiTransName,"CoolingTubeSupportCombiTrans%i",i);
- sprintf(CoolingTubeSupportRotName,"CoolingTubeSupportRot%i",i);
- CoolingTubeSupportLocalMatrix[i] =
- new TGeoCombiTrans(CoolingTubeSupportCombiTransName,
- CoolingTubeSupportTransX[i],
- CoolingTubeSupportTransY[i],
- CoolingTubeSupportTransZ[i],
- new TGeoRotation(CoolingTubeSupportRotName,
- CoolingTubeSupportRotPhi[i],
- CoolingTubeSupportRotTheta[i],
- CoolingTubeSupportRotPsi[i]));
- CoolingTubeSupportCombiTransMatrix[i] = CoolingTubeSupportLocalMatrix[i];
+ - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
+ localcoolingtubesupportrans[1] =
+ new TGeoTranslation(fgkCarbonFiberJunctionLength
+ - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
+ - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])
+ + 0.5*fgkSSDSensorLength,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
+ localcoolingtubesupportrot[i] = new TGeoRotation();
+ localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
+ localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
+ for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
+ localcoolingtubesupportmatrix[i] =
+ new TGeoCombiTrans(*localcoolingtubesupportrans[i],
+ *localcoolingtubesupportrot[i]);
+ fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
+ fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
+ (*localcoolingtubesupportmatrix[0]));
+ /////////////////////////////////////////////////////////////
+ // End Ladder SSD Cooling Tube Support Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoTranslation** localendladdercooltubetrans[2];
+ localendladdercooltubetrans[0] = new TGeoTranslation*[4];
+ localendladdercooltubetrans[1] = new TGeoTranslation*[2];
+ for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
+ localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
+ - (fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax),
+ fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]
+ + 0.5*fgkCoolingTubeSupportWidth,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
+ - (fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax),
+ fgkEndLadderMountingBlockPosition[0]
+ + fgkendladdercoolingsupportdistance[1]
+ + 0.5*fgkCoolingTubeSupportWidth,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberTriangleLength
+ - 2.0*fgkCarbonFiberJunctionLength,
+ 0.0,
+ 0.0);
+ localendladdercooltubetrans[0][3]->SetTranslation(0.0,
+ fgkendladdercoolingsupportdistance[0]
+ + fgkendladdercoolingsupportdistance[1],
+ 0.0);
+ for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
+ localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
+ + fgkCarbonFiberJunctionLength
+ - fgkCoolingTubeSupportLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - 0.5*fgkCoolingTubeSupportWidth
+ -fgkendladdercoolingsupportdistance[2],
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
+ + fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax
+ - fgkCarbonFiberJunctionLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - 0.5*fgkCoolingTubeSupportWidth
+ - fgkendladdercoolingsupportdistance[2],
+ - 0.5*fgkCoolingTubeSupportHeight);
+ fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
+ fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
+ fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
+ fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
+ (*localcoolingtubesupportrot[1]));
+ fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
+ (*localcoolingtubesupportrot[1]));
+ fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
+ fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
+ fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
+ fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
+ fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
+
+ fendladdercoolingtubesupportmatrix[1][0] =
+ new TGeoHMatrix((*localendladdercooltubetrans[1][0])
+ *(*localcoolingtubesupportrot[1]));
+ fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
+ fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
+ fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Tube Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoRotation* localcoolingtuberot = new TGeoRotation();
+ localcoolingtuberot->SetAngles(0.,90.,0.);
+ TGeoTranslation** localcoolingtubetrans[4];
+ TVector3** localcoolingtubevect[4];
+ for(Int_t i=0; i<4; i++){
+ localcoolingtubevect[i] = new TVector3*[2];
+ localcoolingtubetrans[i] = new TGeoTranslation*[2];
+ fcoolingtubematrix[i] = new TGeoHMatrix*[2];
}
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
- ////////////////////////////////////////////////////////
- //Translation Parameters CoolingTube:
- ////////////////////////////////////////////////////////
- const Double_t CoolingTubeTransX[2] = { 0., fgkCoolingTubeSeparation};
- const Double_t CoolingTubeTransY[2] = { fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
- const Double_t CoolingTubeTransZ[2] = { 0.0, 0.};
- ////////////////////////////////////////////////////////
- //Rotational Parameters CoolingTube:
- ////////////////////////////////////////////////////////
- const Double_t CoolingTubeRotPhi[2] = { 0., 0.};
- const Double_t CoolingTubeRotTheta[2] = { 90., 90.};
- const Double_t CoolingTubeRotPsi[2] = { 0., 0.};
- ///////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of CarbonFiberJunction:
- ///////////////////////////////////////////////////////////
- const char* CoolingTubeCombiTransName[fgkCoolingTubeCombiTransNumber] =
- {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
- const char* CoolingTubeRorationName[fgkCoolingTubeCombiTransNumber] =
- {"CoolingTubeRotation0","CoolingTubeRotation1"};
- TGeoCombiTrans *CoolingTubeLocalMatrix[fgkCoolingTubeCombiTransNumber];
- for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
- CoolingTubeLocalMatrix[i] =
- new TGeoCombiTrans(CoolingTubeCombiTransName[i],
- CoolingTubeTransX[i],
- CoolingTubeTransY[i],
- CoolingTubeTransZ[i],
- new TGeoRotation(CoolingTubeRorationName[i],
- CoolingTubeRotPhi[i],
- CoolingTubeRotTheta[i],
- CoolingTubeRotPsi[i] ) );
- CoolingTubeTransMatrix[i] = CoolingTubeLocalMatrix[i];
+ localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+ -fgkCarbonFiberTriangleLength),
+ - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])+
+ 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
+ - 2.0*fgkSSDModuleStiffenerPosition[1]
+ - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
+ - 0.5*fgkCoolingTubeSupportWidth,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
+ localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
+ - 2.0*fgkSSDModuleStiffenerPosition[1]
+ - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
+ + fgkCoolingTubeSupportWidth,
+ localcoolingtubevect[0][0]->Z());
+ localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
+ + fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[0][0]->Y(),
+ localcoolingtubevect[0][0]->Z());
+ localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
+ + fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[0][1]->Y(),
+ localcoolingtubevect[0][1]->Z());
+ localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+ - fgkCarbonFiberTriangleLength),
+ - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])
+ + fgkSSDModuleStiffenerPosition[1]
+ - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
+ + fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[2][0]->Y(),
+ localcoolingtubevect[2][0]->Z());
+ localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+ - fgkCarbonFiberTriangleLength),
+ - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])
+ + fgkSSDSensorLength
+ - 0.5*fgkSSDModuleStiffenerPosition[1],
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
+ + fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[3][0]->Y(),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ for(Int_t i=0; i<4; i++)
+ for(Int_t j=0; j<2; j++){
+ localcoolingtubetrans[i][j] =
+ new TGeoTranslation(localcoolingtubevect[i][j]->X(),
+ localcoolingtubevect[i][j]->Y(),
+ localcoolingtubevect[i][j]->Z());
+ fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
+ * (*localcoolingtuberot));
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD End Ladder Cooling Tube Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
+ localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
+ TGeoTranslation** localendlladdercoolingtubetrans[2];
+ localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
+ localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
+ for(Int_t i=0; i<2; i++)
+ for(Int_t j=0; j<(i==0?6:4); j++)
+ localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
+ localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ 0.5*(fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ - fgkCarbonFiberJunctionLength
+ + fgkCarbonFiberTriangleLength,
+ 0.5*(fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]
+ + 0.5*(fgkendladdercoolingsupportdistance[0]
+ + fgkendladdercoolingsupportdistance[1]
+ + fgkCoolingTubeSupportWidth),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ - fgkCarbonFiberJunctionLength
+ + fgkCarbonFiberTriangleLength,
+ fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]
+ + 0.5*(fgkendladdercoolingsupportdistance[0]
+ + fgkendladdercoolingsupportdistance[1]
+ + fgkCoolingTubeSupportWidth),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[1]
+ - fgkCoolingTubeSupportWidth),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ - fgkCarbonFiberJunctionLength
+ + fgkCarbonFiberTriangleLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[1]
+ - fgkCoolingTubeSupportWidth),
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ - 0.50 * (fgkMountingBlockToSensorSupport
+ - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
+ - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
+ + fgkSSDSensorOverlap
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - fgkendladdercoolingsupportdistance[2]
+ - fgkEndLadderMountingBlockPosition[1]
+ - fgkCoolingTubeSupportWidth)
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - fgkendladdercoolingsupportdistance[2]
+ - fgkCoolingTubeSupportWidth,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ - fgkCarbonFiberJunctionLength
+ + fgkCarbonFiberTriangleLength,
+ - 0.50 * (fgkMountingBlockToSensorSupport
+ - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
+ - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
+ + fgkSSDSensorOverlap
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - fgkendladdercoolingsupportdistance[2]
+ - fgkEndLadderMountingBlockPosition[1]
+ - fgkCoolingTubeSupportWidth)
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - fgkendladdercoolingsupportdistance[2]
+ - fgkCoolingTubeSupportWidth,
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - 0.5*fgkendladdercoolingsupportdistance[2],
+ - 0.5*fgkCoolingTubeSupportHeight);
+ localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
+ - fgkCoolingTubeSupportRmax)
+ - fgkCarbonFiberJunctionLength
+ + fgkCarbonFiberTriangleLength,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - 0.5*fgkendladdercoolingsupportdistance[2],
+ - 0.5*fgkCoolingTubeSupportHeight);
+ fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
+ fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
+ for(Int_t i=0; i<2; i++)
+ for(Int_t j=0; j<(i==0?6:4); j++){
+ fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
+ fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD Hybrid Components Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t khybridmatrixnumber = 3;
+ TGeoTranslation* localhybridtrans[khybridmatrixnumber];
+ localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
+ 0.5*fgkSSDStiffenerWidth,
+ 0.5*fgkSSDStiffenerHeight);
+ localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
+ fgkSSDModuleStiffenerPosition[1],0.0);
+
+ localhybridtrans[2] = new TGeoTranslation(
+ - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
+ - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0]),
+ - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
+ fhybridmatrix = new TGeoHMatrix();
+ for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Block Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t kcoolingblockmatrixnumber = 4;
+ TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
+ localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
+ - fgkCoolingTubeSupportRmin),0.0,
+ 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
+ localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
+ - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
+ 0.0,fgkSSDStiffenerHeight);
+ localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
+ localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
+ fcoolingblocksystematrix = new TGeoHMatrix();
+ for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
+ fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
+ /////////////////////////////////////////////////////////////
+ // SSD Stiffener Flex Transformations
+ /////////////////////////////////////////////////////////////
+ const Int_t klocalflexmatrixnumber = 4;
+ TGeoCombiTrans** localflexmatrix[fgkflexnumber];
+ for(Int_t i=0; i<fgkflexnumber; i++)
+ localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
+ for(Int_t i=0; i<fgkflexnumber; i++)
+ for(Int_t j =0; j<klocalflexmatrixnumber; j++)
+ localflexmatrix[i][j] = new TGeoCombiTrans();
+ Double_t ssdstiffenerseparation = fgkSSDSensorLength
+ - 2.*fgkSSDModuleStiffenerPosition[1]
+ - fgkSSDStiffenerWidth;
+ localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
+ +0.5*fgkSSDStiffenerLength,
+ 0.5*fgkSSDStiffenerWidth,
+ -0.5*fgkSSDStiffenerHeight
+ -0.5*fgkSSDFlexHeight[0]);
+ localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
+ +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
+ -0.5*fgkSSDStiffenerWidth,
+ -0.5*fgkSSDStiffenerHeight
+ -0.5*fgkSSDFlexHeight[0]);
+ TGeoRotation* localflexrot = new TGeoRotation();
+ localflexrot->SetAngles(180.,0.,0.);
+ localflexmatrix[1][0]->SetRotation(localflexrot);
+ for(Int_t i=0; i<fgkflexnumber; i++)
+ for(Int_t j =1; j<klocalflexmatrixnumber; j++)
+ localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
+ for(Int_t i=0; i<fgkflexnumber; i++){
+ fstiffenerflexmatrix[i] = new TGeoHMatrix();
+ for(Int_t j =0; j<klocalflexmatrixnumber; j++)
+ fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
}
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
-/////////////////////////////////////////////////////////////////////////////////
- //Translation Parameters LadderSegment:
- ////////////////////////////////////////////////////////
- const Double_t LadderSegmentTransX[fgkLadderSegmentCombiTransNumber] = { 0.,
- - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
- fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
- fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax),
- 0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)};
- const Double_t LadderSegmentTransY[fgkLadderSegmentCombiTransNumber] = { 0.,
- - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0]),
- fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
- + fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])
- - fgkSSDSensorCenterSupportPosition,
- fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
- - fgkCoolingTubeSupportToCarbonFiber,
- 0.0};
- const Double_t LadderSegmentTransZ[fgkLadderSegmentCombiTransNumber] = { 0.,
- - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
- - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
- 0.,
- - 0.5*fgkCoolingTubeSupportHeight,
- - 0.5*fgkCoolingTubeSupportHeight};
-//////////////////////////////////////////////////
- //Rotational Parameters LadderSegment:
- ////////////////////////////////////////////////////////
- const Double_t LadderSegmentRotPhi[fgkLadderSegmentCombiTransNumber] =
- { 0., 0.,- 90., 0., 0.};
- const Double_t LadderSegmentRotTheta[fgkLadderSegmentCombiTransNumber] =
- { 0., 0., 0., 90., 0.};
- const Double_t LadderSegmentRotPsi[fgkLadderSegmentCombiTransNumber] =
- { 0., 0., 0., 0., 0.};
- //////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of LadderSegment:
- //////////////////////////////////////////////////////
- char LadderSegmentCombiTransName[40];
- char LadderSegmentRotName[40];
- TGeoCombiTrans *LadderSegmentLocalMatrix[fgkLadderSegmentCombiTransNumber];
- for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
- sprintf(LadderSegmentCombiTransName,"LadderSegmentCombiTrans%i",i);
- sprintf(LadderSegmentRotName,"LadderSegmentRot%i",i);
- LadderSegmentLocalMatrix[i] =
- new TGeoCombiTrans(LadderSegmentCombiTransName,
- LadderSegmentTransX[i],
- LadderSegmentTransY[i],
- LadderSegmentTransZ[i],
- new TGeoRotation(LadderSegmentRotName,
- LadderSegmentRotPhi[i],
- LadderSegmentRotTheta[i],
- LadderSegmentRotPsi[i]));
- LadderSegmentCombiTransMatrix[i] = LadderSegmentLocalMatrix[i];
+ /////////////////////////////////////////////////////////////
+ // SSD End Flex Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoRotation* localendflexrot = new TGeoRotation();
+ localendflexrot->SetAngles(0.0,90.0,0.0);
+ TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
+ Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
+ / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
+ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+ * TMath::DegToRad()*ssdflexradiusmax
+ - fgkSSDFlexLength[2]-TMath::Pi()
+ * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
+ Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
+ + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
+ + fgkSSDFlexLength[2];
+ localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
+ 0.5*fgkSSDFlexWidth[0],
+ 2.*fgkSSDStiffenerHeight
+ + 0.5*fgkSSDFlexHeight[0]);
+ localendflexmatrix->SetRotation(localendflexrot);
+ for(Int_t i=0; i<fgkflexnumber; i++)
+ fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
+ /////////////////////////////////////////////////////////////
+ // End Ladder Carbon Fiber Junction
+ /////////////////////////////////////////////////////////////
+ TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
+ TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
+ TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ localendladdercarbonfiberjunctionmatrix[i]
+ = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
+ localendladdercarbonfiberjunctionrot[i]
+ = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
+ localendladdercarbonfiberjunctiontrans[i]
+ = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
+ fendladdercarbonfiberjunctionmatrix[i]
+ = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
}
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
-/////////////////////////////////////////////////////////////////////////////////
- //Translation Parameters EndLadderSegment:
- ////////////////////////////////////////////////////////
- const Double_t EndLadderSegmentTransX[4] = {0.0,
- 0.0,
- - 0.25*(fgkSSDMountingBlockLength[0]
- + fgkSSDMountingBlockLength[1])
- + 0.5*fgkCarbonFiberTriangleLength,
- 0.0};
- const Double_t EndLadderSegmentTransY[4] =
- {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
- i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
- fgkEndLadderMountingBlockPosition[i],
- (1-i)*(fgkEndLadderMountingBlockPosition[i]
- + 0.5*fgkSSDMountingBlockWidth)};
- const Double_t EndLadderSegmentTransZ[4] = {0.0,
- 0.0,
- - fgkSSDMountingBlockHeight[1]
- + 0.5*fgkSSDMountingBlockHeight[0],
- - 0.5*fgkCarbonFiberLowerSupportHeight};
- ////////////////////////////////////////////////////////
- //Rotational Parameters EndLadderSegment:
- ////////////////////////////////////////////////////////
- const Double_t EndLadderSegmentRotPhi[4] = { 0., 90., 0., 0.};
- const Double_t EndLadderSegmentRotTheta[4] = { 90.,-fgkCarbonFiberTriangleAngle,
- 0., 0.};
- const Double_t EndLadderSegmentRotPsi[4] = { 0.,- 90., 0., 0.};
- ////////////////////////////////////////////////////////
- //Name of CombiTrans Transformation of EndLadderSegment:
- ////////////////////////////////////////////////////////
- char EndLadderSegmentCombiTransName[30];
- char EndLadderSegmentRotName[30];
- TGeoCombiTrans *EndLadderSegmentLocalMatrix[fgkEndLadderSegmentCombiTransNumber];
- for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){
- sprintf(EndLadderSegmentCombiTransName,"EndLadderSegmentCombiTrans%i",i);
- sprintf(EndLadderSegmentRotName,"EndLadderSegmentRot%i",i);
- EndLadderSegmentLocalMatrix[i] =
- new TGeoCombiTrans(EndLadderSegmentCombiTransName,
- EndLadderSegmentTransX[i],
- EndLadderSegmentTransY[i],
- EndLadderSegmentTransZ[i],
- new TGeoRotation(EndLadderSegmentRotName,
- EndLadderSegmentRotPhi[i],
- EndLadderSegmentRotTheta[i],
- EndLadderSegmentRotPsi[i]));
- EndLadderSegmentCombiTransMatrix[i] = EndLadderSegmentLocalMatrix[i];
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
+ for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
+ localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
+ }
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
+ for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
+ localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
+ 0.0,0.0);
+ localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
+ * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
+ * SinD(fgkCarbonFiberTriangleAngle),
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
+ - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
}
-}
-/////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
-////////////////////////////////////////////////////////////////////////////////
-// Translation Parameters for LadderCable
-/////////////////////////////////////////
- Double_t SSDFlexRadius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
+ TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
+ TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
+ TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
+ localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
+ localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
+ localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
+ 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
+ localendladdercarbonfiberjunctionglobalmatrix[i] =
+ new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
+ *localendladdercarbonfiberjunctionglobalrot[i]);
+ }
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
+ for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ localendladdercarbonfiberjunctionmatrix[i][j] =
+ new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
+ *localendladdercarbonfiberjunctionrot[i][j]);
+ fendladdercarbonfiberjunctionmatrix[i][j] =
+ new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
+ * (*localendladdercarbonfiberjunctionmatrix[i][j]));
+ }
+ /////////////////////////////////////////////////////////////
+ // End Ladder Carbon Fiber Support
+ /////////////////////////////////////////////////////////////
+ TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
+ for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
+ localendladdercarbonfibertrans[i] = new TGeoTranslation();
+ localendladdercarbonfibertrans[i]->SetTranslation(0.0,
+ i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
+ fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
+ }
+ for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
+ for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
+ fendladdercarbonfibermatrix[i][j] =
+ new TGeoHMatrix((*localendladdercarbonfibertrans[i])
+ *(*fcarbonfibersupportmatrix[j]));
+ /////////////////////////////////////////////////////////////
+ // End Ladder SSD Mounting Block
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
+ + fgkSSDMountingBlockLength[1])
+ + 0.5*fgkCarbonFiberTriangleLength,
+ fgkEndLadderMountingBlockPosition[i],
+ - fgkSSDMountingBlockHeight[1]
+ + 0.5*fgkSSDMountingBlockHeight[0]);
+ TGeoRotation* endladdermountingblockrot = new TGeoRotation();
+ endladdermountingblockrot->SetAngles(0.,90.,0.);
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
+ /////////////////////////////////////////////////////////////
+ // End Ladder SSD Mounting Block Clip Matrix
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
+
+ TGeoRotation* localendladdercliprot = new TGeoRotation();
+ TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
+ localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
+ - fgkSSDMountingBlockLength[1])
+ + fgkSSDMountingBlockLength[0],0.,0.);
+ localendladdercliprot->SetAngles(90.,180.,-90.);
+ TGeoCombiTrans* localendladderclipcombitrans =
+ new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ for(Int_t j=0; j<2; j++){
+ fendladdermountingblockclipmatrix[i][j] =
+ new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
+ if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
+ }
+ /////////////////////////////////////////////////////////////
+ // End Ladder Carbon Fiber Lower Support
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
+ fendladderlowersupptrans[i] =
+ new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
+ + 0.5*fgkSSDMountingBlockWidth),
+ - 0.5*fgkCarbonFiberLowerSupportHeight);
+ fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
+ fgkCarbonFiberLowerSupportVolumePosition[1]
+ + fgkCarbonFiberLowerSupportVolumePosition[0],
+ 0.0);
+ fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
+ /////////////////////////////////////////////////////////////
+ // Matrix for positioning Ladder into mother volume
+ /////////////////////////////////////////////////////////////
+ TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
+ for(Int_t i=0; i<fgkladdernumber; i++)
+ ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
+ TGeoRotation* localladdermotherrot = new TGeoRotation();
+ localladdermotherrot->SetAngles(0.,90.,0.);
+ TGeoTranslation* localladdermothertrans[fgkladdernumber];
+ TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ localladdermothertrans[i] = new TGeoTranslation(0.,
+ - fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ + fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
+ * fgkCarbonFiberJunctionWidth,0.);
+ localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
+ *localladdermotherrot);
+ ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
+ ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
+ }
+ /////////////////////////////////////////////////////////////
+ // Ladder Cables Matrices
+ /////////////////////////////////////////////////////////////
+ Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
+ fgkSSDFlexHeight[1];
- Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
- / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
- Double_t SSDLadderCableTransX[3];
- SSDLadderCableTransX[0] = (SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
- * TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
- * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
- SSDLadderCableTransX[1] = ((SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
- - SSDLadderCableTransX[0]
- / TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
- * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());
- SSDLadderCableTransX[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
- * TMath::DegToRad()*SSDFlexRadiusMax
+ Double_t ssdladdercabletransx[3];
+ ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
+ * SinD(2.*fgkSSDFlexAngle)
+ * CosD(2.*fgkSSDFlexAngle);
+ ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
+ - ssdladdercabletransx[0]
+ / SinD(2.*fgkSSDFlexAngle))
+ * CosD(fgkSSDFlexAngle);
+ ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+ * TMath::DegToRad()*ssdflexradiusmax
- fgkSSDFlexLength[2]-TMath::Pi()
* fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
- fgkSSDLadderCableWidth)
- * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
- Double_t SSDLadderCableTransZ[3] = {SSDLadderCableTransX[0]
- * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
- SSDLadderCableTransX[1]
- * TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
- SSDLadderCableTransX[2]
- * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};
- TGeoRotation* LocalLadderCableRot[3];
- LocalLadderCableRot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
- LocalLadderCableRot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
- LocalLadderCableRot[2] = new TGeoRotation("LocalLadderCableRot2");
- LocalLadderCableRot[2]->SetRotation((*LocalLadderCableRot[1])
- * (*LocalLadderCableRot[0]));
-////////////////////////////////////////////
-// LocalLadderCableCombiTransMatrix
-////////////////////////////////////////////
- const Int_t LocalLadderSideCablesNumber = 2;
- const Int_t LocalLadderCombiTransNumber = 5;
- TGeoCombiTrans** LocalLadderCableCombiTransMatrix[LocalLadderSideCablesNumber];
- for(Int_t i=0; i<LocalLadderSideCablesNumber; i++)
- LocalLadderCableCombiTransMatrix[i] =
- new TGeoCombiTrans*[LocalLadderCombiTransNumber];
-///////////////////////////////////////////
-// Left Side Ladder Cables Transformations
-///////////////////////////////////////////
- LocalLadderCableCombiTransMatrix[0][0] =
+ * CosD(2.*fgkSSDFlexAngle);
+ Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
+ * TanD(2.*fgkSSDFlexAngle),
+ ssdladdercabletransx[1]
+ * TanD(fgkSSDFlexAngle),
+ ssdladdercabletransx[2]
+ * TanD(2.*fgkSSDFlexAngle)};
+ TGeoRotation* localladdercablerot[3];
+ for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
+ localladdercablerot[0]->SetAngles(90.,0.,0.);
+ localladdercablerot[1]->SetAngles(90.,60.,-90.);
+ localladdercablerot[2]->SetRotation((*localladdercablerot[1])
+ * (*localladdercablerot[0]));
+ ////////////////////////////////////////////
+ // LocalLadderCableCombiTransMatrix
+ ////////////////////////////////////////////
+ const Int_t klocalladdersidecablesnumber = 2;
+ const Int_t klocalladdercombitransnumber = 5;
+ TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
+ for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
+ localladdercablecombitransmatrix[i] =
+ new TGeoCombiTrans*[klocalladdercombitransnumber];
+ ///////////////////////////////////////////
+ // Left Side Ladder Cables Transformations
+ ///////////////////////////////////////////
+ localladdercablecombitransmatrix[0][0] =
new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
0.,0.,NULL);
- LocalLadderCableCombiTransMatrix[0][1] = LadderSegmentCombiTransMatrix[1];
- LocalLadderCableCombiTransMatrix[0][2] =
+ localladdercablecombitransmatrix[0][1] =
+ new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
+ - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth
+ + fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0]),
+ - (fgkSSDModuleCoolingBlockToSensor
+ + 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
+ - fgkSSDChipHeight),NULL);
+ localladdercablecombitransmatrix[0][2] =
new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
fgkSSDModuleStiffenerPosition[1],0.,0);
- LocalLadderCableCombiTransMatrix[0][3] = SSDModuleCombiTransMatrix[6];
- LocalLadderCableCombiTransMatrix[0][4] =
- new TGeoCombiTrans(-SSDLadderCableTransX[0]
- - SSDLadderCableTransX[1]-SSDLadderCableTransX[2]
+ localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
+ 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
+ +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+ fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+ - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
+ new TGeoRotation("",180.,0.,0.));
+ localladdercablecombitransmatrix[0][4] =
+ new TGeoCombiTrans(-ssdladdercabletransx[0]
+ - ssdladdercabletransx[1]-ssdladdercabletransx[2]
+ fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
0.,
0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
+ fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
- + SSDLadderCableTransZ[0]-SSDLadderCableTransZ[1]
- + SSDLadderCableTransZ[2],LocalLadderCableRot[2]);
-///////////////////////////////////////////
-// Rigth Side Ladder Cables Transformations
-///////////////////////////////////////////
- for(Int_t i=0; i<LocalLadderCombiTransNumber; i++)
- LocalLadderCableCombiTransMatrix[1][i] =
- (i!=3 ? LocalLadderCableCombiTransMatrix[0][i]:
- SSDModuleCombiTransMatrix[3]);
-///////////////////////////////////////////
-// Setting LadderCableCombiTransMatrix
-///////////////////////////////////////////
-Int_t BeamAxisTrans[3] = {0,0,0};
-switch(iLayer){
-case 5:
- BeamAxisTrans[0] = fgkSSDLay5SensorsNumber/2;
- BeamAxisTrans[1] = BeamAxisTrans[0]+1;
- BeamAxisTrans[2] = BeamAxisTrans[0]-1;
- break;
-case 6:
- BeamAxisTrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
- BeamAxisTrans[1] = BeamAxisTrans[0]+1;
- BeamAxisTrans[2] = BeamAxisTrans[0];
- break;
-}
- TGeoHMatrix* LocalLadderCableHMatrix[LocalLadderSideCablesNumber];
- TGeoRotation* LadderCableRot;
- TGeoTranslation* LadderCableTrans;
- for(Int_t i=0; i<LocalLadderSideCablesNumber; i++){
- LocalLadderCableHMatrix[i] = new TGeoHMatrix();
- for(Int_t j=0; j<LocalLadderCombiTransNumber; j++){
- LocalLadderCableHMatrix[i]->MultiplyLeft(
- LocalLadderCableCombiTransMatrix[i][LocalLadderCombiTransNumber-j-1]);
- }
- LadderCableRot = new TGeoRotation();
- LadderCableRot->SetMatrix(LocalLadderCableHMatrix[i]->GetRotationMatrix());
- LadderCableTrans = new TGeoTranslation();
- Double_t* LadderCableTransVector = LocalLadderCableHMatrix[i]->GetTranslation();
- LadderCableTrans->SetTranslation(LadderCableTransVector[0],
- LadderCableTransVector[1]
- + (i==0 ? BeamAxisTrans[0] : 0.)
+ + ssdladdercabletransz[0]-ssdladdercabletransz[1]
+ + ssdladdercabletransz[2],localladdercablerot[2]);
+ ///////////////////////////////////////////
+ // Rigth Side Ladder Cables Transformations
+ ///////////////////////////////////////////
+ TGeoCombiTrans* localladdercablessdmodulematrix =
+ new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
+ - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
+ fgkSSDStiffenerWidth,
+ - 0.5*fgkSSDFlexHeight[0],NULL);
+ for(Int_t i=0; i<klocalladdercombitransnumber; i++)
+ localladdercablecombitransmatrix[1][i] =
+ (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
+ new TGeoCombiTrans(*localladdercablessdmodulematrix));
+ ///////////////////////////////////////////
+ // Setting LadderCableHMatrix
+ ///////////////////////////////////////////
+ Int_t beamaxistrans[2][3];
+ beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
+ beamaxistrans[0][1] = beamaxistrans[0][0]+1;
+ beamaxistrans[0][2] = beamaxistrans[0][0]-1;
+ beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
+ beamaxistrans[1][1] = beamaxistrans[1][0]+1;
+ beamaxistrans[1][2] = beamaxistrans[1][0];
+ TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
+ TGeoRotation* laddercablerot = new TGeoRotation();
+ TGeoTranslation* laddercabletrans = new TGeoTranslation();
+ TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
+ Double_t* laddercabletransvector;
+ for(Int_t i=0; i<fgkladdercablesnumber; i++){
+ localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
+ fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
+ }
+ for(Int_t i=0; i<fgkladdercablesnumber; i++){
+ for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
+ localladdercablehmatrix[i][j] = new TGeoHMatrix();
+ for(Int_t k=0; k<klocalladdercombitransnumber; k++){
+ localladdercablehmatrix[i][j]->MultiplyLeft(
+ localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
+ }
+ laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
+ laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
+ laddercabletrans->SetTranslation(laddercabletransvector[0],
+ laddercabletransvector[1]
+ + (j==0 ? beamaxistrans[i][0] : 0.)
* fgkCarbonFiberJunctionWidth,
- LadderCableTransVector[2]);
- LadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*LadderCableTrans,
- *LadderCableRot);
- }
- LadderCableCombiTransMatrix[2] =
- AddTranslationToCombiTrans(LadderCableCombiTransMatrix[1],0.,
- BeamAxisTrans[1]*fgkCarbonFiberJunctionWidth,0.);
- LadderCableCombiTransMatrix[3] =
- AddTranslationToCombiTrans(LadderCableCombiTransMatrix[0],0.,
- BeamAxisTrans[2]*fgkCarbonFiberJunctionWidth,0.);
+ laddercabletransvector[2]);
+ laddercablecombitrans->SetRotation(*laddercablerot);
+ laddercablecombitrans->SetTranslation(*laddercabletrans);
+ fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
+ }
+ fladdercablematrix[i][2] =
+ AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
+ beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
+ fladdercablematrix[i][3] =
+ AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
+ beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
+ }
+ for(Int_t i=0; i<fgkladdercablesnumber; i++)
+ for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
+ fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
+ ///////////////////////////////////////////
+ // Setting Ladder HMatrix
+ ///////////////////////////////////////////
+ Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
+ fgkSSDLay6SensorsNumber};
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
+ for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
+ fladdermatrix[i][j] = new TGeoHMatrix();
+ fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+ fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
+ fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
+ }
+ }
+ ///////////////////////////////////////////
+ // Setting SSD Sensor Matrix
+ ///////////////////////////////////////////
+ TGeoCombiTrans* localssdsensorcombitrans[2];
+ TGeoRotation* localssdsensorrot = new TGeoRotation();
+ localssdsensorrot->SetAngles(0.,90.,0.);
+ TGeoTranslation* localssdsensortrans[2];
+ for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
+ localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
+ - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+ 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
+ - fgkSSDSensorSideSupportHeight[0]));
+ localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
+ - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+ 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
+ -fgkSSDModuleCoolingBlockToSensor);
+ for(Int_t i=0; i<2; i++)
+ localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
+ *localssdsensorrot);
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
+ for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
+ switch(i){
+ case 0: //Ladder of Layer5
+ fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
+ * ((j%2==0 ? *localssdsensorcombitrans[0] :
+ *localssdsensorcombitrans[1])));
+ break;
+ case 1: //Ladder of Layer6
+ fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
+ * ((j%2==0 ? *localssdsensorcombitrans[1] :
+ *localssdsensorcombitrans[0])));
+ break;
+ }
+ }
+ }
+ //////////////////////////
+ // Setting SSD End Ladder
+ //////////////////////////
+ for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
+ for(Int_t i=0; i<2; i++){
+ fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
+ fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+ fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
+ fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
+ fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
+ fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
+ fendladdersegmentmatrix[1][i]->RotateZ(180.0);
+ fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
+ }
+ /////////////////////////////////////////////////////
+ // Setting the CombiTransformation to pass ITS center
+ /////////////////////////////////////////////////////
+ Double_t itscentertransz[fgklayernumber];
+ itscentertransz[0] = fgkSSDLay5LadderLength
+ - fgkLay5CenterITSPosition;
+ itscentertransz[1] = fgkSSDLay6LadderLength
+ - fgkLay6CenterITSPosition;
+ Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
+ + 0.5*fgkCoolingTubeSupportHeight;
+ TGeoRotation* itscenterrot[3];
+ for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
+ itscenterrot[0]->SetAngles(90.,180.,-90.);
+ itscenterrot[1]->SetAngles(0.,90.,0.);
+ itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
+ TGeoCombiTrans* itscentercombitrans[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++)
+ itscentercombitrans[i] = new TGeoCombiTrans(0.,
+ itssensortransy,
+ fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - itscentertransz[i],itscenterrot[2]);
+ TGeoRotation** locallayerrot[fgklayernumber];
+ TGeoTranslation** locallayertrans[fgklayernumber];
+ TGeoCombiTrans** locallayercombitrans[fgklayernumber];
+ TGeoTranslation* localbeamaxistrans[fgklayernumber];
+ localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
+ - fgkLay5CenterITSPosition);
+ localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
+ - fgkLay6CenterITSPosition);
+ const Int_t kssdlayladdernumber[fgklayernumber] =
+ {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
+ for(Int_t i=0; i<fgklayernumber; i++){
+ locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
+ locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
+ locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
+ flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
+ }
+ Double_t layerladderangleposition[fgklayernumber] =
+ {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
+ Double_t layerradius = 0.;
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ switch(i){
+ case 0: //Ladder of Layer5
+ layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
+ break;
+ case 1: //Ladder of Layer6
+ layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
+ break;
+ }
+ locallayerrot[i][j] = new TGeoRotation();
+ locallayertrans[i][j] = new TGeoTranslation();
+ locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
+ locallayertrans[i][j]->SetTranslation(layerradius
+ * CosD(90.0+j*layerladderangleposition[i]),
+ layerradius
+ * SinD(90.0+j*layerladderangleposition[i]),0.);
+ locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
+ *locallayerrot[i][j]);
+ flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
+ flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
+ flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
+ delete carbonfiberot[i];
+ delete localcarbonfibersupportmatrix[i];
+ }
+ for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
+ for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
+ delete localcarbonfiberjunctionmatrix[i][j];
+ delete localcarbonfiberjunctionrot[i][j];
+ delete localcarbonfiberjunctiontrans[i][j];
+ }
+ delete [] localcarbonfiberjunctionmatrix[i];
+ delete [] localcarbonfiberjunctionrot[i];
+ delete [] localcarbonfiberjunctiontrans[i];
+ }
+ for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
+ delete localcarbonfiberlowersupportrans[i];
+ for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
+ for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
+ delete localssdsensorsupportmatrix[i][j];
+ delete localssdsensorsupportrot[i][j];
+ delete localssdsensorsupportrans[i][j];
+ }
+ delete [] localssdsensorsupportmatrix[i];
+ delete [] localssdsensorsupportrot[i];
+ delete [] localssdsensorsupportrans[i];
+ }
+ for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
+ delete localcoolingtubesupportmatrix[i];
+ delete localcoolingtubesupportrot[i];
+ delete localcoolingtubesupportrans[i];
+ }
+ for(Int_t i=0; i<4; i++){
+ for(Int_t j=0; j<2; j++){
+ delete localcoolingtubevect[i][j];
+ delete localcoolingtubetrans[i][j];
+ }
+ delete [] localcoolingtubevect[i];
+ delete [] localcoolingtubetrans[i];
+ }
+ delete endladdermountingblockrot;
+ for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
+ for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
+ for(Int_t i=0; i<fgkflexnumber; i++){
+ for(Int_t j=1; j<klocalflexmatrixnumber; j++)
+ delete localflexmatrix[i][j];
+ delete [] localflexmatrix[i];
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length,
- Double_t height,Double_t width,Double_t* thickness){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- const Int_t ShapesNumber = 2;
- Double_t Width[2] = {width,width};
- TVector3** VertexPosition[ShapesNumber];
- for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] =
- new TVector3*[VertexNumber];
- //First Shape Vertex Positioning
- VertexPosition[0][0] = new TVector3();
- VertexPosition[0][1] = new TVector3(height);
- VertexPosition[0][2] = new TVector3(thickness[0]);
- VertexPosition[0][3] = new TVector3(*VertexPosition[0][1]);
- //Second Shape Vertex Positioning
- VertexPosition[1][0] = new TVector3(*VertexPosition[0][0]);
- VertexPosition[1][1] = new TVector3(length);
- VertexPosition[1][2] = new TVector3(thickness[1]);
- VertexPosition[1][3] = new TVector3(VertexPosition[1][1]->X());
- char* SSDSensorSupportShapeName[ShapesNumber] =
- {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
- TGeoArb8* SSDSensorSupportShape[ShapesNumber];
- for(Int_t i = 0; i< ShapesNumber; i++) SSDSensorSupportShape[i] =
- GetArbShape(VertexPosition[i],Width,i==0 ?
- thickness[1]: thickness[0],
- SSDSensorSupportShapeName[i]);
- /////////////////////////////////////
- //Setting Translations and Rotations:
- /////////////////////////////////////
- TGeoRotation* SSDSensorSupportShapeRot[2];
- SSDSensorSupportShapeRot[0] =
- new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
- SSDSensorSupportShapeRot[1] =
- new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
- TGeoTranslation* SSDSensorSupportShapeTrans =
- new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
- 0.5*thickness[0]);
- TGeoCombiTrans* SSDSensorSupportCombiTrans =
- new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
- new TGeoRotation((*SSDSensorSupportShapeRot[1])
- * (*SSDSensorSupportShapeRot[0])));
- TGeoVolume* SSDSensorSupportCompVolume =
- new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
- SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
- SSDSensorSupportShape[0],fgkSSDSensorSupportMedium),1,
- SSDSensorSupportShapeTrans);
- SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
- SSDSensorSupportShape[1],fgkSSDSensorSupportMedium),1,
- SSDSensorSupportCombiTrans);
- return SSDSensorSupportCompVolume;
+ delete localendlladdercoolingtuberot;
+ for(Int_t i=0; i<2; i++){
+ for(Int_t j=0; j<(i==0?6:4); j++)
+ delete localendlladdercoolingtubetrans[i][j];
+ delete [] localendlladdercoolingtubetrans[i];
+ }
+
+ delete localflexrot;
+ delete localendflexrot;
+ delete localendflexmatrix;
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ delete localladdermothertrans[i];
+ delete localladdermothercombitrans[i];
+ }
+ delete localladdermotherrot;
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ delete localendladdercarbonfiberjunctionmatrix[i][j];
+ delete localendladdercarbonfiberjunctionrot[i][j];
+ delete localendladdercarbonfiberjunctiontrans[i][j];
+ }
+ delete [] localendladdercarbonfiberjunctionmatrix[i];
+ delete [] localendladdercarbonfiberjunctionrot[i];
+ delete [] localendladdercarbonfiberjunctiontrans[i];
+ delete localendladdercarbonfiberjunctionglobalrot[i];
+ delete localendladdercarbonfiberjunctionglobaltrans[i];
+ delete localendladdercarbonfiberjunctionglobalmatrix[i];
+ }
+ for(Int_t i=0; i<2; i++){
+ for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
+ delete [] localendladdercooltubetrans[i];
+ }
+ for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
+ delete localendladdercarbonfibertrans[i];
+ for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
+ for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
+ for(Int_t j=0; j<klocalladdercombitransnumber; j++)
+ delete localladdercablecombitransmatrix[i][j];
+ delete []localladdercablecombitransmatrix[i];
+ }
+ delete localendladdercliprot;
+ delete localendladdercliptrans;
+ for(Int_t i=0; i<fgkladdercablesnumber; i++){
+ for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
+ delete localladdercablehmatrix[i][j];
+ delete []localladdercablehmatrix[i];
+ }
+ delete laddercablerot;
+ delete laddercabletrans;
+ delete laddercablecombitrans;
+ delete localladdercablessdmodulematrix;
+ delete localssdsensorrot;
+ for(Int_t i=0; i<2; i++){
+ delete localssdsensortrans[i];
+ delete localssdsensorcombitrans[i];
+ }
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ delete locallayerrot[i][j];
+ delete locallayertrans[i][j];
+ delete locallayercombitrans[i][j];
+ }
+ delete [] locallayerrot[i];
+ delete [] locallayertrans[i];
+ delete [] locallayercombitrans[i];
+ delete localbeamaxistrans[i];
+ }
+ for(Int_t i=0; i<3; i++) delete itscenterrot[i];
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ for(Int_t j=0; j<fgkladdernumber; j++)
+ delete ladderglobalmatrix[i][j];
+ delete [] ladderglobalmatrix[i];
+ }
+ /////////////////////////////////////////////////////////////
+ fTransformationMatrices = kTRUE;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* SSDSensorSupport;
- Double_t SideSupportThickness[2] = {fgkSSDSensorSideSupportThickness[0],
- fgkSSDSensorSideSupportThickness[1]};
- VolumeKind == 0 ? SSDSensorSupport = GetSSDSensorSupportShape(
- fgkSSDSensorSideSupportLength,
- fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
- fgkSSDSensorSideSupportWidth,
- SideSupportThickness) :
- SSDSensorSupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
- fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
- fgkSSDSensorCenterSupportWidth,
- SideSupportThickness);
- return SSDSensorSupport;
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::CreateBasicObjects(){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Objects of SSD Geometry
+ /////////////////////////////////////////////////////////////
+ // SSD Sensor
+ ///////////////////////////////////
+ SetSSDSensor();
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Support
+ /////////////////////////////////////////////////////////////
+ TList* carbonfibersupportlist = GetCarbonFiberSupportList();
+ for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
+ fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Junction
+ /////////////////////////////////////////////////////////////
+ fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
+ /////////////////////////////////////////////////////////////
+ // Carbon Fiber Lower Support
+ /////////////////////////////////////////////////////////////
+ TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
+ for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
+ fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
+ /////////////////////////////
+ // SSD Sensor Support
+ /////////////////////////////
+ for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
+ new TGeoVolume*[fgkssdsensorsupportnumber];
+ Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
+ fgkSSDSensorSideSupportThickness[1]};
+ for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
+ fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
+ fgkSSDSensorSideSupportHeight[i],
+ fgkSSDSensorSideSupportWidth,
+ sidesupporthickness);
+ fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
+ fgkSSDSensorCenterSupportHeight[i],
+ fgkSSDSensorCenterSupportWidth,
+ sidesupporthickness);
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Tube Support
+ /////////////////////////////////////////////////////////////
+ Int_t edgesnumber = 16;
+ fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
+ /////////////////////////////////////////////////////////////
+ // SSD Hybrid
+ /////////////////////////////////////////////////////////////
+ TList* ssdhybridcomponentslist = GetSSDHybridParts();
+ for(Int_t i=0; i<fgkhybridcompnumber; i++)
+ fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Block System
+ /////////////////////////////////////////////////////////////
+ fssdcoolingblocksystem = GetCoolingBlockSystem();
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Tube
+ /////////////////////////////////////////////////////////////
+ TList* coolingtubelist = GetCoolingTubeList();
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++)
+ fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ fendladdercoolingtube[i] =
+ (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
+ /////////////////////////////////////////////////////////////
+ // SSD Flex
+ /////////////////////////////////////////////////////////////
+ fssdstiffenerflex = GetSSDStiffenerFlex();
+ fssdendflex = GetSSDEndFlex();
+ ///////////////////////////////////
+ // End Ladder Carbon Fiber Junction
+ ///////////////////////////////////
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
+ fendladdercarbonfiberjunction[i] =
+ new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ fendladdercarbonfiberjunction[i][0] =
+ GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
+ fendladdercarbonfiberjunction[i][1] =
+ GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
+ }
+ ///////////////////////////////////
+ // End Ladder Mounting Block
+ ///////////////////////////////////
+ fendladdermountingblock = GetSSDMountingBlock();
+ ///////////////////////////////////
+ // End Ladder Mounting Block
+ ///////////////////////////////////
+ fendladdermountingblockclip = GetMountingBlockClip();
+ ///////////////////////////////////
+ // Ladder Support
+ ///////////////////////////////////
+ TList* laddersupportlist = GetMountingBlockSupport(20);
+ fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
+ fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
+ fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
+ fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete carbonfibersupportlist;
+ delete carbonfiberlowersupportlist;
+ delete ssdhybridcomponentslist;
+ delete laddersupportlist;
+ /////////////////////////////////////////////////////////////
+ fBasicObjects = kTRUE;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* SSDSensorSupportAssembly =
- new TGeoVolumeAssembly("SSDSensorSupportAssembly");
- const Int_t VolumeNumber = 2;
- TGeoVolume* SSDSensorSupport[VolumeNumber];
- for(Int_t i=0; i<VolumeNumber; i++) SSDSensorSupport[i] =
- GetSSDSensorSupport(i,n);
- SetSSDSensorSupportCombiTransMatrix();
- for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++)
- SSDSensorSupportAssembly->AddNode((i<2 ? SSDSensorSupport[0]:
- SSDSensorSupport[1]),
- i+1,SSDSensorSupportCombiTransMatrix[i]);
- return SSDSensorSupportAssembly;
+void AliITSv11GeometrySSD::SetSSDSensor(){
+ ////////////////////////////////////////////////////////////////
+ // Method generating SSD Sensors: it sets the private variables
+ // fSSDSensor5, fSSDSensor6
+ ////////////////////////////////////////////////////////////////
+ Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
+ Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
+ TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
+ 0.5*ssdsensitivewidth,
+ 0.5*fgkSSDSensorHeight,
+ 0.5*ssdsensitivelength);
+ TGeoVolume* ssdsensorsensitiveLay5 =
+ new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
+ TGeoVolume* ssdsensorsensitiveLay6 =
+ new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
+ ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
+ ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
+ TGeoBBox* ssdsensorinsensitiveshape[2];
+ ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
+ 0.5*fgkSSDSensorInsensitiveWidth,
+ 0.5*fgkSSDSensorHeight,
+ 0.5*fgkSSDSensorLength);
+ ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
+ 0.5*ssdsensitivewidth,
+ 0.5*fgkSSDSensorHeight,
+ 0.5*fgkSSDSensorInsensitiveWidth);
+ const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
+ "SSDSensorInsensitive2"};
+ TGeoVolume* ssdsensorinsensitive[2];
+ for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
+ new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
+ fSSDSensorMedium);
+ ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
+ }
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing SSD Sensor
+ /////////////////////////////////////////////////////////////
+ TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
+ 0.5*fgkSSDSensorWidth,
+ 0.5*fgkSSDSensorHeight,
+ 0.5*fgkSSDSensorLength);
+ fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
+ fSSDAir);
+ fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
+ fSSDAir);
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<4; i++){
+ fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
+ ssdsensorinsensitive[1],i<2?1:2,
+ new TGeoTranslation(
+ 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
+ * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
+ 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
+ * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
+ fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
+ ssdsensorinsensitive[1],i<2?1:2,
+ new TGeoTranslation(
+ 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
+ * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
+ 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
+ * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
+ }
+ fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
+ fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* SSDModuleVolume[fgkSSDModuleCombiTransNumber-1];
- SSDModuleVolume[0] = GetSSDStiffenerAssembly();
- SSDModuleVolume[1] = GetSSDChipAssembly();
- SSDModuleVolume[2] = GetSSDSensor();
- SSDModuleVolume[3] = GetSSDFlexAssembly();
- SSDModuleVolume[4] = GetSSDCoolingBlockAssembly();
- SSDModuleVolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
- SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
- TGeoCombiTrans* SSDModuleGlobalCombiTrans =
- new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
- fgkSSDModuleStiffenerPosition[0],
- fgkSSDModuleStiffenerPosition[1],0.,NULL);
- TGeoHMatrix* SSDModuleHMatrix[fgkSSDModuleCombiTransNumber];
- TGeoVolume* SSDModule = new TGeoVolumeAssembly("SSDModule");
- for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
- SSDModuleHMatrix[i] = new TGeoHMatrix((*SSDModuleGlobalCombiTrans)
- * (*SSDModuleCombiTransMatrix[i]));
- SSDModule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? SSDModuleVolume[3] :
- SSDModuleVolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
- SSDModuleHMatrix[i]);
- }
- return SSDModule;
+///////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Carbon Fiber Support
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 4;
+ const Int_t kshapesnumber = 2;
+ TVector3** vertexposition[kshapesnumber];
+ for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
+ Double_t carbonfibersupportxaxisEdgeproj =
+ fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
+ * TMath::DegToRad());
+ Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
+ / fgkCarbonFiberSupportXAxisLength);
+ /////////////////////
+ //Vertex Positioning
+ ////////////////////
+ vertexposition[0][0] = new TVector3();
+ vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
+ fgkCarbonFiberSupportYAxisLength);
+ vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
+ carbonfibersupportxaxisEdgeproj
+ * TMath::Tan(theta));
+ vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
+ - carbonfibersupportxaxisEdgeproj,
+ fgkCarbonFiberSupportYAxisLength
+ - vertexposition[0][2]->Y());
+ ////////////////////////////////////////////////////
+ //Setting the parameters for Isometry Transformation
+ ////////////////////////////////////////////////////
+ Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
+ + fgkCarbonFiberSupportTopEdgeDist[0]
+ + fgkCarbonFiberSupportWidth);
+ Double_t* param = new Double_t[4];
+ param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
+ for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
+ new TVector3((GetReflection(vertexposition[0][j],param))->X(),
+ (GetReflection(vertexposition[0][j],param))->Y());
+ char* carbonfibersupportshapename[kshapesnumber] =
+ {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
+ char* carbonfibersupportname[kshapesnumber] =
+ {"CarbonFiberSupport1","CarbonFiberSupport2"};
+ TGeoArb8* carbonfibersupportshape[kshapesnumber];
+ TGeoVolume* carbonfibersupport[kshapesnumber];
+ TList* carbonfibersupportlist = new TList();
+ Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
+ Double_t carbonfibersupportheight =
+ carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
+ *TMath::DegToRad());
+ for(Int_t i = 0; i< kshapesnumber; i++){
+ carbonfibersupportshape[i] =
+ GetArbShape(vertexposition[i],width,carbonfibersupportheight,
+ carbonfibersupportshapename[i],i==0 ? 1: -1);
+ carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
+ carbonfibersupportshape[i],fSSDCarbonFiberMedium);
+ carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
+ carbonfibersupportlist->Add(carbonfibersupport[i]);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i< kshapesnumber; i++){
+ for(Int_t j=0; j< kvertexnumber; j++)
+ delete vertexposition[i][j];
+ delete [] vertexposition[i];
+ }
+ delete [] param;
+ /////////////////////////////////////////////////////////////
+ return carbonfibersupportlist;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
+TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
+ /////////////////////////////////////////////////////////////
+ // Method generating SSD Carbon Fiber Junction
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 6;
+ TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
+ Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
+ * TMath::DegToRad()),-1.,0.};
+ TVector3* vertex[kvertexnumber];
+ vertex[0] = new TVector3();
+ vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
+ * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
+ * TMath::DegToRad()),
+ fgkCarbonFiberJunctionEdge[0]
+ * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
+ * TMath::DegToRad()));
+ vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
+ fgkCarbonFiberJunctionEdge[1]);
+ vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
+ vertex[1] = GetReflection(vertex[5],reflectionparam);
+ vertex[2] = GetReflection(vertex[4],reflectionparam);
+ Double_t xvertexpoints[6], yvertexpoints[6];
+ for(Int_t i=0; i<kvertexnumber; i++)
+ xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
+ carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
+ carbonfiberjunctionshape->DefineSection(0,-0.5*width);
+ carbonfiberjunctionshape->DefineSection(1,0.5*width);
+ TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
+ carbonfiberjunctionshape,fSSDCarbonFiberMedium);
+ carbonfiberjunction->SetLineColor(fColorCarbonFiber);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
+ /////////////////////////////////////////////////////////////
+ return carbonfiberjunction;
+}
////////////////////////////////////////////////////////////////////////////////
- Double_t fgkSSDSensorSensitiveLength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
- Double_t fgkSSDSensorSensitiveWidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
- TGeoBBox* SSDSensorSensitiveShape = new TGeoBBox("SSDSensorSensitiveShape",
- 0.5*fgkSSDSensorSensitiveLength,
- 0.5*fgkSSDSensorSensitiveWidth,
- 0.5*fgkSSDSensorHeight);
- TGeoVolume* SSDSensorSensitive =
- new TGeoVolume(fgkSSDSensitiveVolName,SSDSensorSensitiveShape,fgkSSDSensorMedium);
- SSDSensorSensitive->SetLineColor(fColorSilicon);
- TGeoBBox* SSDSensorInsensitiveShape[2];
- SSDSensorInsensitiveShape[0] = new TGeoBBox("SSDSensorInSensitiveShape1",
- 0.5*fgkSSDSensorLength,
- 0.5*fgkSSDSensorInsensitiveWidth,
- 0.5*fgkSSDSensorHeight);
- SSDSensorInsensitiveShape[1] = new TGeoBBox("SSDSensorInSensitiveShape2",
- 0.5*fgkSSDSensorInsensitiveWidth,
- 0.5*fgkSSDSensorSensitiveWidth,
- 0.5*fgkSSDSensorHeight);
- const char* SSDSensorInsensitiveName[2] = {"SSDSensorInsensitive1",
- "SSDSensorInsensitive2"};
- TGeoVolume* SSDSensorInsensitive[2];
- for(Int_t i=0; i<2; i++){ SSDSensorInsensitive[i] =
- new TGeoVolume(SSDSensorInsensitiveName[i],SSDSensorInsensitiveShape[i],
- fgkSSDSensorMedium);
- SSDSensorInsensitive[i]->SetLineColor(fColorCarbonFiber);
- }
- TGeoVolume* SSDSensorInsensitiveVol =
- new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
- for(Int_t i=0; i<4; i++)
- SSDSensorInsensitiveVol->AddNode(i%2==0 ? SSDSensorInsensitive[0]:
- SSDSensorInsensitive[1],i<2?1:2,
- new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
- * (SSDSensorSensitiveShape->GetDX()+SSDSensorInsensitiveShape[1]->GetDX()),
- 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
- * (SSDSensorSensitiveShape->GetDY()+SSDSensorInsensitiveShape[0]->GetDY()),0.));
- TGeoVolume* SSDSensor = new TGeoVolumeAssembly("SSDSensor");
- SSDSensor->AddNode(SSDSensorSensitive,1),SSDSensor->AddNode(SSDSensorInsensitiveVol,1);
- return SSDSensor;
+TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Carbon Fiber Lower Support
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 4;
+ const Int_t kshapesnumber = 2;
+ Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
+ fgkCarbonFiberLowerSupportWidth};
+ TVector3** vertexposition[kshapesnumber];
+ for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
+ new TVector3*[kvertexnumber];
+ //First Shape Vertex Positioning
+ vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
+ vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
+ - fgkCarbonFiberLowerSupportLowerLenght);
+ vertexposition[0][2] = new TVector3();
+ vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
+ //Second Shape Vertex Positioning
+ Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
+ - fgkCarbonFiberLowerSupportVolumePosition[0])
+ / fgkCarbonFiberTriangleLength);
+ vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
+ vertexposition[0][0]->X()*TMath::Tan(theta)
+ + fgkCarbonFiberLowerSupportVolumePosition[0]);
+ vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
+ vertexposition[0][1]->X()*TMath::Tan(theta)
+ + fgkCarbonFiberLowerSupportVolumePosition[0]);
+ vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
+ vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
+ fgkCarbonFiberLowerSupportVolumePosition[1]);
+ char* carbonfiberlowersupportshapename[kshapesnumber] =
+ {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
+ char* carbonfiberlowersupportname[kshapesnumber] =
+ {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
+ TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
+ TGeoVolume* carbonfiberlowersupport[kshapesnumber];
+ TList* carbonfiberlowersupportlist = new TList();
+ for(Int_t i = 0; i< kshapesnumber; i++){
+ carbonfiberlowersupportshape[i] =
+ GetArbShape(vertexposition[i],width,
+ fgkCarbonFiberLowerSupportHeight,
+ carbonfiberlowersupportshapename[i]);
+ carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
+ carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
+ carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
+ carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i< kshapesnumber; i++){
+ for(Int_t j=0; j< kvertexnumber; j++)
+ delete vertexposition[i][j];
+ delete [] vertexposition[i];
+ }
+ /////////////////////////////////////////////////////////////
+ return carbonfiberlowersupportlist;
+}
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
+ Double_t width, Double_t* thickness)const{
+ /////////////////////////////////////////////////////////////
+ // Method generating the Sensor Support
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 6;
+ TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
+ TVector3* vertexposition[kvertexnumber];
+ vertexposition[0] = new TVector3();
+ vertexposition[1] = new TVector3(0.0,length);
+ vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
+ vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
+ vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
+ vertexposition[5] = new TVector3(vertexposition[4]->X());
+ Double_t xvertexpoints[6], yvertexpoints[6];
+ for(Int_t i=0; i<kvertexnumber; i++)
+ xvertexpoints[i] = vertexposition[i]->X(),
+ yvertexpoints[i] = vertexposition[i]->Y();
+ ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
+ ssdsensorsupportshape->DefineSection(0,-0.5*width);
+ ssdsensorsupportshape->DefineSection(1,0.5*width);
+ TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
+ ssdsensorsupportshape,fSSDSensorSupportMedium);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for (Int_t i=0; i<kvertexnumber; i++)
+ delete vertexposition[i];
+ /////////////////////////////////////////////////////////////
+ return ssdsensorsupport;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly(){
////////////////////////////////////////////////////////////////////////////////
- const Int_t SSDChipRowNumber = 2;
- TGeoBBox* SSDChipCompShape[2];
- SSDChipCompShape[0] = new TGeoBBox("SSDChipCompShape",
- 0.5*fgkSSDChipLength,
- 0.5*fgkSSDChipWidth,
- 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
- SSDChipCompShape[1] = new TGeoBBox("SSDChipGlueCompShape",
- 0.5*fgkSSDChipLength,
- 0.5*fgkSSDChipWidth,
- 0.5*fgkSSDChipGlueHeight);
- TGeoVolume* SSDChipComp[2];
- SSDChipComp[0] = new TGeoVolume("SSDChipComp",SSDChipCompShape[0],fgkSSDChipMedium);
- SSDChipComp[1] = new TGeoVolume("SSDChipGlueComp",SSDChipCompShape[1],
- fgkSSDChipGlueMedium);
- SSDChipComp[0]->SetLineColor(fColorSilicon);
- SSDChipComp[1]->SetLineColor(fColorEpoxy);
- TGeoTranslation* SSDChipCompTrans[2];
- SSDChipCompTrans[0] = new TGeoTranslation(0.,0.,-SSDChipCompShape[1]->GetDZ());
- SSDChipCompTrans[1] = new TGeoTranslation(0.,0.,SSDChipCompShape[0]->GetDZ());
- TGeoVolume* SSDChip = new TGeoVolumeAssembly("SSDChip");
- for(Int_t i=0; i<2; i++) SSDChip->AddNode(SSDChipComp[i],1,SSDChipCompTrans[i]);
- Double_t SSDChipSeparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
- fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
- - 0.5*fgkSSDChipWidth)};
- TGeoVolume* SSDChipAssembly = new TGeoVolumeAssembly("SSDChipAssembly");
- for(Int_t i=0; i<SSDChipRowNumber; i++)
- for(Int_t j=0; j<fgkSSDChipNumber; j++)
- SSDChipAssembly->AddNode(SSDChip,fgkSSDChipNumber*i+j+1,
- new TGeoTranslation(j*SSDChipSeparation[0],i*SSDChipSeparation[1],0.));
- return SSDChipAssembly;
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Cooling Tube Support
+ /////////////////////////////////////////////////////////////
+ if(nedges%2!=0) nedges--;
+ const Int_t kvertexnumber = nedges+5;
+ Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
+ / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
+ Double_t angle = 90.+phi;
+ Double_t psi = 90.-phi;
+ ///////////////////////////////////////
+ // Vertex Positioning for TGeoXTru
+ ///////////////////////////////////////
+ TVector3** vertexposition = new TVector3*[kvertexnumber];
+ vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
+ fgkCoolingTubeSupportRmin*SinD(angle));
+ vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
+ fgkCoolingTubeSupportRmax*SinD(angle));
+ vertexposition[2] = new TVector3(vertexposition[1]->X(),
+ fgkCoolingTubeSupportRmax);
+ vertexposition[3] = new TVector3(-vertexposition[1]->X(),
+ fgkCoolingTubeSupportRmax);
+ vertexposition[4] = new TVector3(-vertexposition[1]->X(),
+ vertexposition[1]->Y());
+ for(Int_t i=0; i<nedges; i++)
+ vertexposition[i+5] =
+ new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
+ fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Cooling Tube Support Arc Part
+ ///////////////////////////////////////////////////////////////////////
+ TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
+ Double_t* xvertexpoints = new Double_t[kvertexnumber];
+ Double_t* yvertexpoints = new Double_t[kvertexnumber];
+ for(Int_t i=0; i<kvertexnumber; i++){
+ xvertexpoints[i] = vertexposition[i]->X();
+ yvertexpoints[i] = vertexposition[i]->Y();
+ }
+ coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
+ yvertexpoints);
+ coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+ coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+ TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
+ coolingtubesupportarcshape,
+ fSSDTubeHolderMedium);
+ coolingtubesupportarc->SetLineColor(fColorG10);
+ //////////////////////////////////////////////////////////////////////////
+ // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
+ //////////////////////////////////////////////////////////////////////////
+ TGeoTubeSeg* coolingtubesupportsegshape =
+ new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
+ fgkCoolingTubeSupportRmax,
+ 0.5*fgkCoolingTubeSupportWidth,
+ phi,360-phi);
+ TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
+ coolingtubesupportsegshape,
+ fSSDTubeHolderMedium);
+ coolingtubesupportseg->SetLineColor(fColorG10);
+ //////////////////////////////////////////////////////////////////////////
+ // TGeoBBox Volume definition for Cooling Tube Support Box Part
+ //////////////////////////////////////////////////////////////////////////
+ Double_t* boxorigin = new Double_t[3];
+ Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
+ boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
+ TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
+ 0.5*fgkCoolingTubeSupportHeight,
+ 0.5*fgkCoolingTubeSupportWidth,boxorigin);
+ TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
+ coolingtubesupportboxshape,fSSDTubeHolderMedium);
+ coolingtubesupportbox->SetLineColor(fColorG10);
+ //////////////////////////////////////////////////////////////////////////
+ // Cooling Tube for Cooling Tube Support
+ //////////////////////////////////////////////////////////////////////////
+ TGeoXtru* coolingtubearcshape[2];
+ coolingtubearcshape[0] = new TGeoXtru(2);
+ Double_t* xvert = new Double_t[nedges+2];
+ Double_t* yvert = new Double_t[nedges+2];
+ Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
+ ////////////////////////////////////////
+ // Positioning the vertices for TGeoXTru
+ ////////////////////////////////////////
+ xvert[0] = 0., yvert[0] = 0.;
+ xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
+ for(Int_t i=0; i< nedges; i++)
+ xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
+ yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
+ ////////////////////////////////////////
+ // Defining TGeoXTru PolyGone
+ ////////////////////////////////////////
+ coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
+ coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+ coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+ coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
+ fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
+ TGeoVolume* coolingtubearc[2];
+ coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
+ coolingtubearcshape[0],fSSDCoolingTubeWater);
+ coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
+ coolingtubearcshape[1],fSSDCoolingTubePhynox);
+ coolingtubearc[0]->SetLineColor(fColorWater);
+ coolingtubearc[1]->SetLineColor(fColorPhynox);
+ ////////////////////////////////////////////
+ // Defining TGeoTubeSeg Part of Cooling Tube
+ ////////////////////////////////////////////
+ TGeoTubeSeg* coolingtubesegshape[2];
+ coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
+ coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
+ 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
+ TGeoVolume* coolingtubeseg[2];
+ coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
+ coolingtubesegshape[0],fSSDCoolingTubePhynox);
+ coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
+ coolingtubesegshape[1],fSSDCoolingTubeWater);
+ coolingtubeseg[0]->SetLineColor(fColorPhynox);
+ coolingtubeseg[1]->SetLineColor(fColorWater);
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing Cooling Tube Support
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
+ const Int_t kvirtualvertexnumber = 8;
+ TVector3* virtualvertex[kvirtualvertexnumber];
+ ////////////////////////////////////////
+ // Positioning the vertices for TGeoXTru
+ ////////////////////////////////////////
+ virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
+ virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
+ virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
+ virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
+ virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
+ virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
+ virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
+ virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
+ Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
+ for(Int_t i=0; i< kvirtualvertexnumber; i++)
+ xmothervertex[i] = virtualvertex[i]->X(),
+ ymothervertex[i] = virtualvertex[i]->Y();
+ ////////////////////////////////////////
+ // Defining TGeoXTru PolyGone
+ ////////////////////////////////////////
+ virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
+ ymothervertex);
+ virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
+ virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
+ TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
+ virtualCoolingTubeSupportShape,fSSDAir);
+ ////////////////////////////////////////
+ // Positioning Volumes in Virtual Volume
+ ////////////////////////////////////////
+ TGeoRotation* coolingtubesupportrot = new TGeoRotation();
+ coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
+ virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
+ virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
+ virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
+ virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
+ virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
+ virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
+ virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete [] vertexposition;
+ delete xvertexpoints;
+ delete yvertexpoints;
+ delete xvert;
+ delete yvert;
+ for(Int_t i=0; i< kvirtualvertexnumber; i++)
+ delete virtualvertex[i];
+ /////////////////////////////////////////////////////////////
+ return virtualcoolingtubesupport;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t SSDStiffenerNumber = 2;
- Double_t SSDStiffenerSeparation = fgkSSDSensorLength
+TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
+ /////////////////////////////////////////////////////////////
+ // Method generating List containing SSD Hybrid Components
+ /////////////////////////////////////////////////////////////
+ TList* ssdhybridlist = new TList();
+ const Int_t kssdstiffenernumber = 2;
+ Double_t ssdstiffenerseparation = fgkSSDSensorLength
- 2.*fgkSSDModuleStiffenerPosition[1]
- fgkSSDStiffenerWidth;
- TGeoVolume* SSDStiffener = new TGeoVolumeAssembly("SSDStiffener");
-////////////////////////////
-// Stiffener Volumes
-///////////////////////////
- const Int_t StiffenerBoxNumber = 6;
- TGeoBBox* SSDStiffenerBoxShapes[StiffenerBoxNumber];
- SSDStiffenerBoxShapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
- 0.5* fgkSSDStiffenerLength,
- 0.5* fgkSSDStiffenerWidth,
- 0.5*(fgkSSDStiffenerHeight
- - fgkSSDConnectorHeight));
- SSDStiffenerBoxShapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
- 0.5*(fgkSSDConnectorPosition[0]
- - 2.0* fgkSSDConnectorLength
- - fgkSSDConnectorSeparation),
- 0.5* fgkSSDStiffenerWidth,
- 0.5* fgkSSDConnectorHeight);
- SSDStiffenerBoxShapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
- 0.5*(fgkSSDConnectorSeparation
- + 2.* fgkSSDConnectorLength),
- 0.5* fgkSSDConnectorPosition[1],
- 0.5* fgkSSDConnectorHeight);
- SSDStiffenerBoxShapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
- SSDStiffenerBoxShapes[2]->GetDX(),
- 0.5*(fgkSSDStiffenerWidth
- - fgkSSDConnectorPosition[1]
- - fgkSSDConnectorWidth),
- 0.5* fgkSSDConnectorHeight);
- SSDStiffenerBoxShapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
- 0.5* fgkSSDConnectorSeparation,
- 0.5* fgkSSDConnectorWidth,
- 0.5* fgkSSDConnectorHeight);
- SSDStiffenerBoxShapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
- 0.5*(fgkSSDStiffenerLength
- - fgkSSDConnectorPosition[0]),
- 0.5* fgkSSDStiffenerWidth,
- 0.5* fgkSSDConnectorHeight);
- TGeoVolume* SSDStiffenerBox[StiffenerBoxNumber];
- char SSDStiffenerBoxName[30];
- for(Int_t i=0; i<StiffenerBoxNumber; i++){
- sprintf(SSDStiffenerBoxName,"SSDStiffenerBox%i",i+1);
- SSDStiffenerBox[i] = new TGeoVolume(SSDStiffenerBoxName,SSDStiffenerBoxShapes[i],
- fgkSSDStiffenerMedium);
- SSDStiffenerBox[i]->SetLineColor(fColorStiffener);
- }
-////////////////////////////
-// Connector
-///////////////////////////
- TGeoBBox* SSDConnectorShape = new TGeoBBox("SSDConnectorShape",
- 0.5*fgkSSDConnectorLength,
- 0.5*fgkSSDConnectorWidth,
- 0.5*fgkSSDConnectorHeight);
- TGeoVolume* SSDConnector = new TGeoVolume("SSDConnector",SSDConnectorShape,
- fgkSSDStiffenerConnectorMedium);
- SSDConnector->SetLineColor(fColorAl);
- const Int_t SSDConnectorNumber = 2;
- TGeoTranslation* SSDConnectorTrans[SSDConnectorNumber];
- SSDConnectorTrans[0] = new TGeoTranslation("SSDConnectorTrans1",
- - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
- - fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
- SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
- - SSDConnectorShape->GetDY(),
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
- SSDConnectorTrans[1] = new TGeoTranslation("SSDConnectorTrans2",
- - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
- - 0.5*fgkSSDConnectorLength,
- SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
- - SSDConnectorShape->GetDY(),
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
- for(Int_t i=0; i<SSDConnectorNumber; i++)
- SSDStiffener->AddNode(SSDConnector,i+1,SSDConnectorTrans[i]);
-//////////////////////////////////////
-// TGeoTranslation for Stiffener Boxes
-//////////////////////////////////////
- TGeoTranslation* SSDStiffenerBoxTrans[StiffenerBoxNumber];
- SSDStiffenerBoxTrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
- SSDStiffenerBoxTrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
- - (SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[1]->GetDX()),
- 0.,
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[1]->GetDZ());
- SSDStiffenerBoxTrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
- - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[2]->GetDX()
- + fgkSSDConnectorPosition[0],
- SSDStiffenerBoxShapes[0]->GetDY()-SSDStiffenerBoxShapes[2]->GetDY(),
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[2]->GetDZ());
- SSDStiffenerBoxTrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
- - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[3]->GetDX()
- + fgkSSDConnectorPosition[0],
- - SSDStiffenerBoxShapes[0]->GetDY()+SSDStiffenerBoxShapes[3]->GetDY(),
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[3]->GetDZ());
- SSDStiffenerBoxTrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
- - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
- - 0.5*fgkSSDConnectorSeparation-2.*SSDConnectorShape->GetDX(),
- SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
- - SSDConnectorShape->GetDY(),
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
- SSDStiffenerBoxTrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
- - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
- + SSDStiffenerBoxShapes[5]->GetDX(),
- 0.,
- SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[5]->GetDZ());
- for(Int_t i=0; i<StiffenerBoxNumber; i++)
- SSDStiffener->AddNode(SSDStiffenerBox[i],1,SSDStiffenerBoxTrans[i]);
- TGeoCombiTrans* SSDStiffenerCombiTrans[SSDStiffenerNumber];
- char SSDStiffenerCombiTransName[30];
- for(Int_t i=0; i<SSDStiffenerNumber; i++){
- sprintf(SSDStiffenerCombiTransName,"SSDStiffenerCombiTrans%i",i+1);
- SSDStiffenerCombiTrans[i] = new TGeoCombiTrans(SSDStiffenerCombiTransName,
- 0.,i*SSDStiffenerSeparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
+ Double_t ssdchipcablesradius[kssdstiffenernumber];
+ for(Int_t i=0; i<kssdstiffenernumber; i++)
+ ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
+ - fgkSSDChipCablesHeight[0]
+ - fgkSSDChipCablesHeight[1]);
+ /////////////////////////////////////////////////////////////
+ // Mother Volumes Containers
+ /////////////////////////////////////////////////////////////
+ const Int_t kmothernumber = 2;
+ const Int_t kmothervertexnumber = 12;
+ Double_t xmothervertex[kmothernumber][kmothervertexnumber];
+ Double_t ymothervertex[kmothernumber][kmothervertexnumber];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
+ xmothervertex[0][1] = xmothervertex[0][0];
+ xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
+ xmothervertex[0][3] = xmothervertex[0][2];
+ xmothervertex[0][4] = xmothervertex[0][0];
+ xmothervertex[0][5] = xmothervertex[0][4];
+ xmothervertex[0][6] = -xmothervertex[0][0];
+ xmothervertex[0][7] = xmothervertex[0][6];
+ xmothervertex[0][8] = -xmothervertex[0][2];
+ xmothervertex[0][9] = xmothervertex[0][8];
+ xmothervertex[0][10] = xmothervertex[0][7];
+ xmothervertex[0][11] = xmothervertex[0][10];
+ for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
+ for(Int_t i = 0; i<kmothernumber; i++){
+ ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
+ + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
+ ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
+ ymothervertex[i][2] = ymothervertex[i][1];
+ ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][4] = ymothervertex[i][3];
+ ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
+ ymothervertex[i][6] = ymothervertex[i][5];
+ ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
+ ymothervertex[i][8] = ymothervertex[i][7];
+ ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][10] = ymothervertex[i][9];
+ ymothervertex[i][11] = ymothervertex[i][0];
}
+ TGeoXtru* ssdhybridmothershape[kmothernumber];
+ TGeoVolume* ssdhybridmother[kmothernumber];
+ const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
+ for(Int_t i=0; i<kmothernumber; i++){
+ ssdhybridmothershape[i] = new TGeoXtru(2);
+ ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
+ ymothervertex[i]);
+ ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
+ -fgkSSDChipCablesHeight[i+2]);
+ ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
+ ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
+ fSSDAir);
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD Stiffener
+ /////////////////////////////////////////////////////////////
+ TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
+ 0.5*fgkSSDStiffenerLength,
+ 0.5*fgkSSDStiffenerWidth,
+ 0.5*fgkSSDStiffenerHeight);
+ TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
+ fSSDStiffenerMedium);
+ ssdstiffener->SetLineColor(fColorStiffener);
+ TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
+ for(Int_t i=0; i<kssdstiffenernumber; i++)
+ ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
+ /////////////////////////////////////////////////////////////
+ // SSD Chip System
+ /////////////////////////////////////////////////////////////
+ TList* ssdchipsystemlist = GetSSDChipSystem();
+ Double_t ssdchipseparation = fgkSSDSensorLength
+ - 2.*fgkSSDModuleStiffenerPosition[1]
+ - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
+ - 0.5*fgkSSDChipWidth);
+ Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
+ + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
+ TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
+ - 0.5*ssdchipsystemlength,
+ 0.5*(ssdstiffenerseparation-ssdchipseparation),
+ - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
////////////////////////////
// Capacitor 0603-2200 nF
///////////////////////////
- const Int_t Capacitor0603Number = 5;
- TGeoBBox* Capacitor0603Shape = new TGeoBBox("Capacitor0603Shape",
+ const Int_t knapacitor0603number = 5;
+ TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
0.5*fgkSSDCapacitor0603Length,
0.5*fgkSSDCapacitor0603Width,
0.5*fgkSSDCapacitor0603Height);
- TGeoVolume* Capacitor0603 = new TGeoVolume("Capacitor0603",Capacitor0603Shape,
- fgkSSDStiffener0603CapacitorMedium);
- Capacitor0603->SetLineColor(fColorAl);
+ TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
+ fSSDStiffener0603CapacitorMedium);
+ capacitor0603->SetLineColor(fColorAl);
+ for(Int_t i=0; i<kmothernumber; i++){
+ for(Int_t j=0; j<kssdstiffenernumber; j++){
+ ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
+ for(Int_t k=1; k<knapacitor0603number+1; k++){
+ ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
+ new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
+ j*ssdstiffenerseparation
+ + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
+ + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
+ - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
+ }
+ }
+ ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
+ ssdhybridlist->Add(ssdhybridmother[i]);
+ }
+/////////////////////////////////////////////////////////////
+// Mother Volume Containing Capacitor Part
+/////////////////////////////////////////////////////////////
+ const Int_t kcapacitormothernumber = 8;
+ Double_t xcapacitorvertex[kcapacitormothernumber];
+ Double_t ycapacitorvertex[kcapacitormothernumber];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
+ xcapacitorvertex[1] = xcapacitorvertex[0];
+ xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
+ xcapacitorvertex[3] = xcapacitorvertex[2];
+ xcapacitorvertex[4] = xcapacitorvertex[0];
+ xcapacitorvertex[5] = xcapacitorvertex[0];
+ xcapacitorvertex[6] = -xcapacitorvertex[0];
+ xcapacitorvertex[7] = xcapacitorvertex[6];
+ ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
+ ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
+ ycapacitorvertex[2] = ycapacitorvertex[1];
+ ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
+ ycapacitorvertex[4] = ycapacitorvertex[3];
+ ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
+ ycapacitorvertex[6] = ycapacitorvertex[5];
+ ycapacitorvertex[7] = ycapacitorvertex[0];
+ TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
+ ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
+ ycapacitorvertex);
+ ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
+ ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
+ TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
+ fSSDAir);
////////////////////////////
-// Capacitor 1812-330 nF
+// Connector
///////////////////////////
- TGeoBBox* Capacitor1812Shape = new TGeoBBox("Capacitor1812Shape",
+ const Int_t kssdconnectornumber = 2;
+ TGeoBBox* ssdconnectorshape[kssdconnectornumber];
+ Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
+ Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
+ + fgkSSDConnectorAlHeight};
+ const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
+ TGeoVolume* ssdconnector[kssdconnectornumber];
+ for(Int_t i=0; i<kssdconnectornumber; i++){
+ ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
+ 0.5*fgkSSDConnectorWidth,
+ 0.5*((1-i)*fgkSSDConnectorAlHeight
+ + i*fgkSSDConnectorNiHeight),
+ i==0? ssdAlconnectororigin : ssdNiconnectororigin);
+ ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
+ i==0 ? fSSDAlTraceFlexMedium
+ : fSSDStiffenerConnectorMedium);
+ ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
+ }
+ TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
+ ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
+ + fgkSSDConnectorPosition[0]
+ - fgkSSDConnectorSeparation
+ - 1.5*fgkSSDConnectorLength,
+ ssdstiffenerseparation+ssdstiffenershape->GetDY()
+ - fgkSSDConnectorPosition[1]
+ - ssdconnectorshape[0]->GetDY(),0.0);
+ ssdconnectortrans[1] = new TGeoTranslation(
+ - ssdstiffenershape->GetDX()
+ + fgkSSDConnectorPosition[0]
+ - 0.5*fgkSSDConnectorLength,
+ ssdstiffenerseparation+ssdstiffenershape->GetDY()
+ - fgkSSDConnectorPosition[1]
+ - ssdconnectorshape[0]->GetDY(),0.0);
+ ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
+ - fgkSSDConnectorPosition[0]
+ + fgkSSDConnectorSeparation
+ + 1.5*fgkSSDConnectorLength,
+ -(ssdstiffenershape->GetDY()
+ - fgkSSDConnectorPosition[1]
+ - ssdconnectorshape[0]->GetDY()),0.0);
+ ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
+ - fgkSSDConnectorPosition[0]
+ + 0.5*fgkSSDConnectorLength,
+ -(ssdstiffenershape->GetDY()
+ - fgkSSDConnectorPosition[1]
+ - ssdconnectorshape[0]->GetDY()),0.0);
+ for(Int_t i=0; i<2*kssdconnectornumber; i++)
+ for(Int_t j=0; j<kssdconnectornumber; j++)
+ ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
+////////////////////////////
+// Capacitor 1812-330 nF
+///////////////////////////
+ Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
+ TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
0.5*fgkSSDCapacitor1812Length,
0.5*fgkSSDCapacitor1812Width,
- 0.5*fgkSSDCapacitor1812Height);
- TGeoVolume* Capacitor1812 = new TGeoVolume("Capacitor1812",Capacitor1812Shape,
- fgkSSDStiffener1812CapacitorMedium);
- Capacitor1812->SetLineColor(fColorAl);
- TGeoTranslation* Capacitor1812Trans = new TGeoTranslation("Capacitor1812Trans",
- 0.,
- 0.5*fgkSSDStiffenerWidth+SSDStiffenerSeparation
- - Capacitor1812Shape->GetDY()-fgkSSDConnectorPosition[1],
- SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
- + 0.5*fgkSSDCapacitor1812Height);
+ 0.5*fgkSSDCapacitor1812Height,
+ ssdcapacitor1812origin);
+ TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
+ fSSDStiffener1812CapacitorMedium);
+ capacitor1812->SetLineColor(fColorAl);
+ TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
+ 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
+ - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
+ ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
////////////////////////////
//Hybrid Wire
////////////////////////////
- Double_t WireX = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
+ Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
- 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
- fgkSSDConnectorSeparation;
- Double_t WireY = SSDStiffenerSeparation+fgkSSDStiffenerWidth
+ Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
- 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
- Double_t SSDWireRadius = TMath::Sqrt(TMath::Power(WireX,2.)
- + TMath::Power(WireY,2));
- Double_t WireAngle = TMath::ATan(WireX/WireY);
- TGeoTube *HybridWireShape = new TGeoTube("HybridWireShape", 0.,
- fgkSSDWireRadius, 0.5*SSDWireRadius);
- TGeoVolume* HybridWire = new TGeoVolume("HybridWire",HybridWireShape,
- fgkSSDStiffenerHybridWireMedium);
- HybridWire->SetLineColor(fColorPhynox);
- TGeoCombiTrans* HybridWireCombiTrans[2];
- HybridWireCombiTrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
+ Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
+ + TMath::Power(wirey,2));
+ Double_t wireangle = TMath::ATan(wirex/wirey);
+ TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
+ fgkSSDWireRadius, 0.5*ssdwireradius);
+ TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
+ fSSDStiffenerHybridWireMedium);
+ hybridwire->SetLineColor(fColorPhynox);
+ TGeoCombiTrans* hybridwirecombitrans[2];
+ hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
+ 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
- 0.5*SSDWireRadius-0.5*fgkSSDStiffenerWidth
+ 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
+ fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
- SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
- + fgkSSDWireRadius,
+ ssdstiffenershape->GetDZ()
+ + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
new TGeoRotation("HybridWireRot1",0.,90.,0.));
- HybridWireCombiTrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
- 0.,
- - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
- 0.,
- new TGeoRotation("HybridWireRot2",
- - WireAngle*TMath::RadToDeg(),0.,0.));
- TGeoHMatrix* HybridWireMatrix = new TGeoHMatrix();
- HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[0]);
- HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[1]);
-////////////////////////////
-// Stiffener Assembly
-///////////////////////////
- TGeoVolume* SSDStiffenerAssembly =
- new TGeoVolumeAssembly("SSDStiffenerAssembly");
- SSDStiffenerAssembly->AddNode(HybridWire,1,HybridWireMatrix);
- for(Int_t i=0; i<SSDStiffenerNumber; i++) {
- SSDStiffenerAssembly->AddNode(SSDStiffener,i+1,SSDStiffenerCombiTrans[i]);
- for(Int_t j=1; j<Capacitor0603Number+1; j++){
- SSDStiffenerAssembly->AddNode(Capacitor0603,Capacitor0603Number*i+j,new TGeoTranslation("",(j-3.
- )/6*fgkSSDStiffenerLength,
- i*SSDStiffenerSeparation+
- 0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
- +(i==0? -1:+1)*fgkSSDCapacitor0603Width),
- -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
- }
- if(i==1) SSDStiffenerAssembly->AddNode(Capacitor1812,1,Capacitor1812Trans);
-}
- return SSDStiffenerAssembly;
+ hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
+ 0.0,
+ - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
+ 0.0,
+ new TGeoRotation("HybridWireRot2",
+ - wireangle*TMath::RadToDeg(),0.,0.));
+ TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
+ hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
+ hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
+ ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
+ ssdhybridlist->Add(ssdhybridcapacitormother);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete hybridwirecombitrans[0];
+ delete hybridwirecombitrans[1];
+ delete ssdchipsystemlist;
+ return ssdhybridlist;
+ /////////////////////////////////////////////////////////////
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth,
- char* side){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t SSDChipCablesLayNumber = 2;
- Int_t SSDChipCablesColor[2] = {fColorAl,fColorPolyhamide};
- Double_t SSDChipCablesRadius[2];
- SSDChipCablesRadius[0] = 0.25*(SSDChipCablesHeigth
- - fgkSSDChipCablesHeight[0]
- - fgkSSDChipCablesHeight[1]);
- SSDChipCablesRadius[1] = SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0];
- Double_t SSDChipCablesPieceLength = 0.5*(fgkSSDChipCablesWidth[0]
- - 2.*TMath::Pi()*SSDChipCablesRadius[0]
- - SSDChipCablesRadius[0]
- - fgkSSDChipCablesWidth[1]
- - fgkSSDChipCablesWidth[2]
- - (side=="Right" ? 0 :
- fgkSSDModuleStiffenerPosition[1]
- + TMath::Pi()*(0.5*fgkSSDSensorHeight
- + fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1])));
- //////////////////////////
- //Box and Tube Seg Shapes
- //////////////////////////
- char* SSDChipCablesBoxShapeName[2*SSDChipCablesLayNumber] =
- {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
- "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
- char* SSDChipCablesTubeSegShapeName[2*SSDChipCablesLayNumber] =
- {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
- "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
- TGeoBBox** SSDChipCablesBoxShape[SSDChipCablesLayNumber];
- TGeoTubeSeg** SSDChipCablesTubeSegShape[SSDChipCablesLayNumber];
- for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
- SSDChipCablesBoxShape[i] = new TGeoBBox*[2];
- SSDChipCablesTubeSegShape[i] = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
- SSDChipCablesBoxShape[i][0] = new TGeoBBox(SSDChipCablesBoxShapeName[2*i],
- 0.5*SSDChipCablesPieceLength,
- 0.5*fgkSSDChipCablesLength[1],
- 0.5*fgkSSDChipCablesHeight[i]);
- SSDChipCablesBoxShape[i][1] = new TGeoBBox(SSDChipCablesBoxShapeName[2*i+1],
- 0.5*(SSDChipCablesPieceLength+SSDChipCablesRadius[0]
- + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),
- 0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
- SSDChipCablesTubeSegShape[i][0] =
- new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
- SSDChipCablesRadius[1]-i*fgkSSDChipCablesHeight[1],
- SSDChipCablesRadius[i],0.5*fgkSSDChipCablesLength[1],
- 0.,180.);
- SSDChipCablesTubeSegShape[i][1] =
- new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i+1],
- SSDChipCablesRadius[0]+i*fgkSSDChipCablesHeight[0],
- SSDChipCablesRadius[0]+fgkSSDChipCablesHeight[0]
- + i*fgkSSDChipCablesHeight[1],
- 0.5*fgkSSDChipCablesLength[1],0.,180.);
- if(side!="Right") SSDChipCablesTubeSegShape[i][2] =
- new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
- 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
- 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1],
- 0.5*fgkSSDChipCablesLength[1],0.,180.);
- }
- //////////////////////////
- //Box under Chip
- //////////////////////////
- char SSDUnderChipCablesBoxShapeName[30];
- char SSDUnderChipCablesBoxName[30];
- char SSDUnderChipCablesBoxTransName[30];
- TGeoBBox* SSDUnderChipCablesBoxShape[SSDChipCablesLayNumber];
- TGeoVolume* SSDUnderChipCablesBox[SSDChipCablesLayNumber];
- TGeoTranslation* SSDUnderChipCablesBoxTrans[SSDChipCablesLayNumber];
- for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
- sprintf(SSDUnderChipCablesBoxShapeName,"SSDUnderChipCablesBoxShape%i",i+1);
- sprintf(SSDUnderChipCablesBoxName,"SSDUnderChipCablesBox%i",i+1);
- sprintf(SSDUnderChipCablesBoxTransName,"SSDUnderChipCablesBoxTrans%i",i+1);
- SSDUnderChipCablesBoxShape[i] =
- new TGeoBBox(SSDUnderChipCablesBoxShapeName,
- 0.5*fgkSSDChipWidth,
- 0.5*fgkSSDChipCablesLength[1],
- 0.5*fgkSSDChipCablesHeight[i]);
- SSDUnderChipCablesBox[i] = new TGeoVolume(SSDUnderChipCablesBoxName,
- SSDUnderChipCablesBoxShape[i],
- (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
- SSDUnderChipCablesBox[i]->SetLineColor(SSDChipCablesColor[i]);
- SSDUnderChipCablesBoxTrans[i] =
- new TGeoTranslation(SSDUnderChipCablesBoxTransName,
- (side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
- 0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
- +0.5*fgkSSDChipCablesLength[1],
- (i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Block System
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Block and Cooling Tube Transformations
+ /////////////////////////////////////////////////////////////
+ TGeoRotation* localcoolingblockrot = new TGeoRotation();
+ localcoolingblockrot->SetAngles(0.,90.,0.);
+ TGeoCombiTrans* localcoolingblockmatrix =
+ new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
+ TGeoTranslation* localcoolingblocktrans;
+ TVector3* coolingblocktransvector;
+ coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
+ + fgkSSDCoolingBlockLength,
+ fgkSSDSensorLength
+ - 2.*fgkSSDModuleStiffenerPosition[1]
+ - fgkSSDCoolingBlockWidth);
+ const Int_t kcoolingblocktransnumber = 2;
+ const Int_t kcoolingblocknumber = 4;
+ TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
+ TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
+ TGeoRotation* localcoolingtuberot = new TGeoRotation();
+ localcoolingtuberot->SetAngles(0.0,90.0,0.0);
+ TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
+ localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
+ 0.5*fgkSSDCoolingBlockWidth,
+ fgkSSDCoolingBlockHoleCenter);
+ TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
+ *localcoolingtuberot);
+ Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
+ for(Int_t i=0; i<kcoolingblocktransnumber; i++){
+ for(Int_t j=0; j<kcoolingblocktransnumber; j++){
+ localcoolingblocktrans=
+ new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
+ j*coolingblocktransvector->Y(),
+ - 0.5*(fgkSSDCoolingBlockHoleCenter
+ + fgkCoolingTubeRmax));
+ coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
+ *(*localcoolingblockmatrix));
+ coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
+ *(*localcoolingtubematrix));
+ }
}
- //////////////////
- //Trapezoid Shapes
- //////////////////
- const Int_t SSDChipCablesVertexNumber = 2;
- const Int_t SSDChipCablesTrapezoidNumber = 2;
- TVector3** SSDChipCablesTrapezoidVertex[SSDChipCablesVertexNumber];
- for(Int_t i = 0; i< SSDChipCablesTrapezoidNumber; i++)
- SSDChipCablesTrapezoidVertex[i] = new TVector3*[SSDChipCablesVertexNumber];
- //First Shape Vertex Positioning
- SSDChipCablesTrapezoidVertex[0][0] = new TVector3();
- SSDChipCablesTrapezoidVertex[0][1] =
- new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
- //Second Shape Vertex Positioning
- SSDChipCablesTrapezoidVertex[1][0] =
- new TVector3(*SSDChipCablesTrapezoidVertex[0][0]);
- SSDChipCablesTrapezoidVertex[1][1] =
- new TVector3(*SSDChipCablesTrapezoidVertex[0][1]);
- //Setting the names of shapes and volumes
- char* SSDChipCablesTrapezoidBoxShapeName[SSDChipCablesTrapezoidNumber] =
- {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
- char* SSDChipCablesTrapezoidShapeName[SSDChipCablesTrapezoidNumber] =
- {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
- char* SSDChipCablesTrapezoidBoxName[SSDChipCablesTrapezoidNumber] =
- {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
- char* SSDChipCablesTrapezoidName[SSDChipCablesTrapezoidNumber] =
- {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
- char* SSDChipCablesTrapezoidAssemblyName[SSDChipCablesTrapezoidNumber] =
- {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
- //Setting the Shapes
- TGeoBBox* SSDChipCablesTrapezoidBoxShape[SSDChipCablesTrapezoidNumber];
- TGeoArb8* SSDChipCablesTrapezoidShape[SSDChipCablesTrapezoidNumber];
- //Setting the Volumes
- TGeoVolume* SSDChipCablesTrapezoidBox[SSDChipCablesTrapezoidNumber];
- TGeoVolume* SSDChipCablesTrapezoid[SSDChipCablesTrapezoidNumber];
- TGeoVolume* SSDChipCablesTrapezoidAssembly[SSDChipCablesTrapezoidNumber];
- Double_t SSDChipCablesTrapezoidWidth[SSDChipCablesVertexNumber] =
- {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
- for(Int_t i=0; i<SSDChipCablesTrapezoidNumber; i++){
- SSDChipCablesTrapezoidBoxShape[i] =
- new TGeoBBox(SSDChipCablesTrapezoidBoxShapeName[i],
- 0.5*fgkSSDChipCablesLength[1],
- 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
- 0.5*fgkSSDChipCablesHeight[i]);
- SSDChipCablesTrapezoidShape[i] =
- GetTrapezoidShape(SSDChipCablesTrapezoidVertex[i],
- SSDChipCablesTrapezoidWidth,
- fgkSSDChipCablesHeight[i],
- SSDChipCablesTrapezoidShapeName[i]);
- SSDChipCablesTrapezoidBox[i] =
- new TGeoVolume(SSDChipCablesTrapezoidBoxName[i],
- SSDChipCablesTrapezoidBoxShape[i],
- (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
- SSDChipCablesTrapezoid[i] = new TGeoVolume(SSDChipCablesTrapezoidName[i],
- SSDChipCablesTrapezoidShape[i],
- (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
- SSDChipCablesTrapezoidBox[i]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesTrapezoid[i]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesTrapezoidAssembly[i] =
- new TGeoVolumeAssembly(SSDChipCablesTrapezoidAssemblyName[i]);
- SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoidBox[i],1,
- new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
- 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
- SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],0,
- new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
- SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],1,
- new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing CoolingBlock System
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
+ const Int_t kmothervertexnumber = 16;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////fgkCoolingTubeSupportRmax
+ xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
+ xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
+ + fgkSSDCoolingBlockWidth;
+ xmothervertex[2] = coolingblocktransvector->X()
+ + fgkSSDCoolingBlockLength
+ + 4*coolingtubedistance;
+ ymothervertex[2] = ymothervertex[1];
+ xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
+ xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
+ ymothervertex[4] = ymothervertex[0];
+ xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
+ xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
+ ymothervertex[6] = ymothervertex[5];
+ xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
+ - fgkSSDCoolingBlockWidth;
+ xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
+ xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
+ - coolingtubedistance;
+ xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
+ ymothervertex[10] = ymothervertex[9];
+ xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
+ xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
+ xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
+ xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
+ ymothervertex[14] = ymothervertex[13];
+ xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
+ //////////////////////////////////////////////////////////
+ coolingsystemothershape->DefinePolygon(kmothervertexnumber,
+ xmothervertex,ymothervertex);
+ coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
+ + fgkCoolingTubeRmax));
+ coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
+ + fgkCoolingTubeRmax));
+ TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
+ coolingsystemothershape,fSSDAir);
+ /////////////////////////////////////////////////////////////
+ // SSD Cooling Tube Part
+ /////////////////////////////////////////////////////////////
+ TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
+ coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*fgkSSDCoolingBlockWidth);
+ coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ 0.5*fgkSSDCoolingBlockWidth);
+ TGeoVolume* coolingtube[fgkcoolingtubenumber];
+ coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
+ fSSDCoolingTubePhynox);
+ coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
+ fSSDCoolingTubeWater);
+ coolingtube[0]->SetLineColor(fColorPhynox);
+ coolingtube[1]->SetLineColor(fColorWater);
+ TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
+ /////////////////////////////////////////////////////////////
+ // Adding Cooling block to mother volume
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<kcoolingblocknumber; i++){
+ coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
+ coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
+ coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
}
- /////////////////////////////
- //Box and Tube Seg CombiTrans
- /////////////////////////////
- TGeoTranslation* SSDChipCablesBoxTrans[2*SSDChipCablesLayNumber];
- SSDChipCablesBoxTrans[0] =
- new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
- SSDChipCablesBoxTrans[1] =
- new TGeoTranslation("SSDChipCablesLay1Box2Trans",
- SSDChipCablesBoxShape[0][1]->GetDX()
- - 0.5*SSDChipCablesPieceLength,
- 0.0,
- - 2.*SSDChipCablesRadius[0]
- - fgkSSDChipCablesHeight[0]);
- SSDChipCablesBoxTrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
- 0.0,
- 0.0,
- 0.5*(fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1]));
- SSDChipCablesBoxTrans[3] =
- new TGeoTranslation("SSDChipCablesLay2Box2Trans",
- SSDChipCablesBoxShape[1][1]->GetDX()
- - 0.5*SSDChipCablesPieceLength,
- 0.0,
- - 2.*SSDChipCablesRadius[0]
- - 0.5*fgkSSDChipCablesHeight[1]
- - 1.5*fgkSSDChipCablesHeight[0]);
- TGeoRotation* SSDChipCablesRot[3];
- SSDChipCablesRot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
- SSDChipCablesRot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
- SSDChipCablesRot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
- TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
- (side=="Right" ? 0 : 1))];
- SSDChipCablesTubeSegCombiTrans[0] =
- new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
- 0.5*SSDChipCablesPieceLength,
- 0.0,
- SSDChipCablesRadius[0]
- - 0.5*fgkSSDChipCablesHeight[0],
- new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
- SSDChipCablesTubeSegCombiTrans[1] =
- new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
- - 0.5*SSDChipCablesPieceLength,
- 0.0,
- - SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
- new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
- SSDChipCablesTubeSegCombiTrans[2] =
- new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
- 0.5*SSDChipCablesPieceLength,
- 0.0,
- SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
- new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
- SSDChipCablesTubeSegCombiTrans[3] =
- new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
- - 0.5*SSDChipCablesPieceLength,
- 0.0,
- - SSDChipCablesRadius[0]+0.5*fgkSSDChipCablesHeight[0]
- - fgkSSDChipCablesHeight[0],
- new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
- SSDChipCablesTubeSegCombiTrans[4] =
- new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
- 0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
- + fgkSSDModuleStiffenerPosition[1],
- 0.0,
- - 2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
- - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1]),
- new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
- SSDChipCablesTubeSegCombiTrans[5] =
- new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
- 0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
- + fgkSSDModuleStiffenerPosition[1],
- 0.0,
- - 2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
- - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1]),
- new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
- TGeoCombiTrans* SSDChipCablesTrapezoidCombiTrans[SSDChipCablesLayNumber];
- SSDChipCablesTrapezoidCombiTrans[0] = (side=="Right" ?
- new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
- 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
- + SSDChipCablesRadius[0],
- - 0.5*fgkSSDChipCablesLength[1],
- - fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
- new TGeoRotation("",90.,0.,0.)) :
- new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
- - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
- + 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
- + SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
- 0.5*fgkSSDChipCablesLength[1],
- - 2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
- - 2.*SSDChipCablesRadius[0]-fgkSSDSensorHeight,
- new TGeoRotation("",-90.,0.,0.)));
- SSDChipCablesTrapezoidCombiTrans[1] = (side=="Right" ?
- new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
- 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
- + SSDChipCablesRadius[0],
- - 0.5*fgkSSDChipCablesLength[1],
- - 0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
- - fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
- new TGeoRotation("",90.,0.,0.)) :
- new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
- - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
- + 0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
- + SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
- 0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
- + fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
- - fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0]
- - fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));
- //////////////////////////
- //Box and Tube Seg Volumes
- //////////////////////////
- char* SSDChipCablesBoxName[2*SSDChipCablesLayNumber] =
- {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
- "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
- char* SSDChipRightCablesTubeSegName[2*SSDChipCablesLayNumber] =
- {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
- "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
- char* SSDChipLeftCablesTubeSegName[2*SSDChipCablesLayNumber] =
- {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
- "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
- char* SSDChipCablesLayAssemblyName[SSDChipCablesLayNumber] =
- {"SSDChipCablesLay1","SSDChipCablesLay2"};
- TGeoVolume** SSDChipCablesBox[SSDChipCablesLayNumber];
- TGeoVolume** SSDChipCablesTubeSeg[SSDChipCablesLayNumber];
- TGeoVolume* SSDChipCablesLayAssembly[SSDChipCablesLayNumber];
- for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
- TGeoMedium* SSDChipCablesLayMed =
- (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium);
- SSDChipCablesBox[i] = new TGeoVolume*[2];
- SSDChipCablesTubeSeg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
- SSDChipCablesBox[i][0] = new TGeoVolume(SSDChipCablesBoxName[2*i],
- SSDChipCablesBoxShape[i][0],SSDChipCablesLayMed);
- SSDChipCablesBox[i][1] = new TGeoVolume(SSDChipCablesBoxName[2*i+1],
- SSDChipCablesBoxShape[i][1],SSDChipCablesLayMed);
- SSDChipCablesTubeSeg[i][0] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i],
- SSDChipCablesTubeSegShape[i][0],SSDChipCablesLayMed);
- SSDChipCablesTubeSeg[i][1] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i+1],
- SSDChipCablesTubeSegShape[i][1],SSDChipCablesLayMed);
- SSDChipCablesBox[i][0]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesBox[i][1]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesTubeSeg[i][0]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesTubeSeg[i][1]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesLayAssembly[i] = new TGeoVolumeAssembly(SSDChipCablesLayAssemblyName[i]);
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][0],1,
- SSDChipCablesBoxTrans[2*i]);
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][1],1,
- SSDChipCablesBoxTrans[2*i+1]);
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][0],1,
- SSDChipCablesTubeSegCombiTrans[2*i]);
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][1],1,
- SSDChipCablesTubeSegCombiTrans[2*i+1]);
- if(side!="Right"){
- SSDChipCablesTubeSeg[i][2] = new TGeoVolume(SSDChipLeftCablesTubeSegName[2*i],
- SSDChipCablesTubeSegShape[i][2],
- SSDChipCablesLayMed);
- SSDChipCablesTubeSeg[i][2]->SetLineColor(SSDChipCablesColor[i]);
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][2],1,
- SSDChipCablesTubeSegCombiTrans[4+i]);
- }
- SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTrapezoidAssembly[i],1,
- SSDChipCablesTrapezoidCombiTrans[i]);
- }
- TGeoCombiTrans* SSDChipCablesCombiTrans[SSDChipCablesLayNumber];
- SSDChipCablesCombiTrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
- (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
- 0.5*fgkSSDChipCablesLength[0],
- - (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
- - 0.5*fgkSSDChipCablesHeight[1]),
- new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
- SSDChipCablesCombiTrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
- (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
- 0.5*fgkSSDChipCablesLength[0],
- - (2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
- - 0.5*fgkSSDChipCablesHeight[1]),
- new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
- TGeoVolume* SSDChipCablesAssembly =
- new TGeoVolumeAssembly("SSDChipCables");
- for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
- SSDChipCablesAssembly->AddNode(SSDChipCablesLayAssembly[i],1,
- SSDChipCablesCombiTrans[i]);
- SSDChipCablesAssembly->AddNode(SSDUnderChipCablesBox[i],1,SSDUnderChipCablesBoxTrans[i]);
- }
- return SSDChipCablesAssembly;
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete coolingblocktransvector;
+ delete localcoolingblocktrans;
+ delete localcoolingblockrot;
+ delete localcoolingblockmatrix;
+ delete localcoolingtubetrans;
+ delete localcoolingtuberot;
+ /////////////////////////////////////////////////////////////
+ // Checking overlaps
+ /////////////////////////////////////////////////////////////
+ //coolingsystemother->CheckOverlaps(0.01);
+ /////////////////////////////////////////////////////////////
+ return coolingsystemother;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t ChipCablesNumber = 2;
- Double_t ChipCablesTransVector = fgkSSDSensorLength
- - 2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth
- - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
- char* SSDChipCablesName[ChipCablesNumber] = {"Right","Left"};
- TGeoVolume* SSDChipCables[ChipCablesNumber];
- TGeoVolume* SSDChipCablesAssembly =
- new TGeoVolumeAssembly("SSDChipCablesAssembly");
- for(Int_t i=0; i<ChipCablesNumber; i++) SSDChipCables[i] =
- GetSSDChipCables(SSDChipCablesHeigth,SSDChipCablesName[i]);
- for(Int_t i=0; i<ChipCablesNumber; i++)
- for(Int_t j=0; j<fgkSSDChipNumber; j++)
- SSDChipCablesAssembly->AddNode(SSDChipCables[i],fgkSSDChipNumber*i+j+1,
- new TGeoTranslation(-(SSDChipCablesName[i]=="Left" ? 1. : 0.)
- * ChipCablesTransVector,(j-0.5)*fgkSSDChipCablesLength[0]
- + 0.5*fgkSSDChipCablesLength[1],0.));
- return SSDChipCablesAssembly;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t SSDFlexRadius, Double_t SSDFlexHeigth){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t SSDFlexVolumeNumber = 3;
- TGeoVolume* SSDFlexVolume[SSDFlexVolumeNumber];
- ////////////////////////
- // Setting Display Color
- ////////////////////////
- Int_t SSDFlexColor;
- SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
- TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
- fgkSSDKaptonFlexMedium);
- ////////////////////////
- // SSDFlexTrapezoidShape
- ////////////////////////
- const Int_t SSDFlexVertexNumber = 2;
- Double_t SSDFlexWidth[SSDFlexVertexNumber] = {fgkSSDFlexWidth[1],
- fgkSSDFlexWidth[0]};
- TVector3* SSDFlexVertex[SSDFlexVertexNumber];
- SSDFlexVertex[0] = new TVector3();
- SSDFlexVertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
- TGeoArb8* SSDFlexTrapezoidShape = GetTrapezoidShape(SSDFlexVertex,
- SSDFlexWidth,SSDFlexHeigth,
- "SSDFlexTrapezoidShape");
- SSDFlexVolume[0] = new TGeoVolume("SSDFlexTrapezoid",SSDFlexTrapezoidShape,SSDFlexMed);
- SSDFlexVolume[0]->SetLineColor(SSDFlexColor);
- /////////////////////////
- //SSDFlexTubeSeg Assembly
- /////////////////////////
- const Int_t SSDFlexTubeSegNumber = 2;
- TGeoTubeSeg* SSDFlexTubeSegShape[SSDFlexTubeSegNumber];
- Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
- / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
- SSDFlexTubeSegShape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
- SSDFlexRadius,SSDFlexRadius+SSDFlexHeigth,
- 0.5*fgkSSDFlexWidth[0],0.,180.);
- SSDFlexTubeSegShape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
- SSDFlexRadiusMax-SSDFlexRadius-SSDFlexHeigth,
- SSDFlexRadiusMax-SSDFlexRadius,0.5*fgkSSDFlexWidth[0],
- 0.,2.*fgkSSDFlexAngle);
- TGeoRotation** SSDFlexTubSegRot[SSDFlexTubeSegNumber];
- for(Int_t i = 0; i<SSDFlexTubeSegNumber; i++)
- SSDFlexTubSegRot[i] = new TGeoRotation*[2];
- SSDFlexTubSegRot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90., 0.);
- SSDFlexTubSegRot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
- SSDFlexTubSegRot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90., 0.);
- SSDFlexTubSegRot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
- TGeoCombiTrans* SSDFlexTubeSegCombiTrans[SSDFlexTubeSegNumber];
- SSDFlexTubeSegCombiTrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
- fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
- SSDFlexRadius+0.5*SSDFlexHeigth,
- new TGeoRotation((*SSDFlexTubSegRot[0][1])
- * (*SSDFlexTubSegRot[0][0])));
- SSDFlexTubeSegCombiTrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
- fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
- 0.5*fgkSSDFlexWidth[0],
- SSDFlexRadiusMax+0.5*SSDFlexHeigth+SSDFlexRadius,
- new TGeoRotation((*SSDFlexTubSegRot[1][1])
- * (*SSDFlexTubSegRot[1][0])));
- SSDFlexVolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
- TGeoVolume* SSDFlexTubeSeg[SSDFlexTubeSegNumber];
- char SSDFlexTubeSegName[30];
- for(Int_t i=0; i<SSDFlexTubeSegNumber; i++){
- sprintf(SSDFlexTubeSegName,"SSDFlexTubeSeg%i",i+1);
- SSDFlexTubeSeg[i] = new TGeoVolume(SSDFlexTubeSegName,SSDFlexTubeSegShape[i],
- SSDFlexMed);
- SSDFlexTubeSeg[i]->SetLineColor(SSDFlexColor);
- SSDFlexVolume[1]->AddNode(SSDFlexTubeSeg[i],1,SSDFlexTubeSegCombiTrans[i]);
- }
- ///////////
- //Box Shape
- ///////////
- const Int_t SSDFlexBoxNumber = 7;
- Double_t SSDFlexBoxLength[SSDFlexBoxNumber];
- SSDFlexBoxLength[0] = 0.5*(fgkSSDChipNumber
+TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
+ /////////////////////////////////////////////////////////////
+ // SSD Flex
+ /////////////////////////////////////////////////////////////
+ const Int_t kssdflexlayernumber = 2;
+ TGeoXtru* ssdflexshape[kssdflexlayernumber];
+ for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
+ const Int_t kmothervertexnumber = 17;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ /////////////////////////////////////////////
+ // Auxiliary variables for vertex positioning
+ /////////////////////////////////////////////
+ const Int_t kssdflexboxnumber = 5;
+ Double_t ssdflexboxlength[kssdflexboxnumber];
+ ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
* fgkSSDChipLength+(fgkSSDChipNumber-1)
* fgkSSDChipSeparationLength
- fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
- (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
- SSDFlexBoxLength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
- SSDFlexBoxLength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
+ ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
+ ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
- fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
- SSDFlexBoxLength[3] = fgkSSDFlexHoleWidth;
- SSDFlexBoxLength[4] = fgkSSDFlexLength[1]-SSDFlexBoxLength[0]
- - SSDFlexBoxLength[1];
- SSDFlexBoxLength[5] = fgkSSDFlexLength[2];
- SSDFlexBoxLength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
- * TMath::DegToRad()*SSDFlexRadiusMax
- - fgkSSDFlexLength[2]-TMath::Pi()
- * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
- Double_t SSDFlexBoxWidth[SSDFlexBoxNumber];
- SSDFlexBoxWidth[0] = fgkSSDFlexWidth[0];
- SSDFlexBoxWidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
- SSDFlexBoxWidth[2] = fgkSSDFlexHoleWidth;
- SSDFlexBoxWidth[3] = SSDFlexBoxWidth[2]-fgkSSDFlexHoleLength;
- SSDFlexBoxWidth[4] = fgkSSDFlexWidth[0];
- SSDFlexBoxWidth[5] = fgkSSDFlexWidth[0];
- SSDFlexBoxWidth[6] = fgkSSDFlexWidth[0];
- TGeoBBox* SSDFlexBoxShape[SSDFlexBoxNumber+1];
- for(Int_t i=0; i<SSDFlexBoxNumber+1; i++) SSDFlexBoxShape[i] =
- (i!= SSDFlexBoxNumber ? new TGeoBBox("SSDFlexBoxShape",
- 0.5*SSDFlexBoxLength[i],
- 0.5*SSDFlexBoxWidth[i],0.5*SSDFlexHeigth) :
- SSDFlexBoxShape[2]);
- //////////////////////////////
- //SSDFlex Box Shape CombiTrans
- //////////////////////////////
- TGeoCombiTrans* SSDFlexBoxCombiTrans[SSDFlexBoxNumber+1];
- SSDFlexBoxCombiTrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
- SSDFlexVertex[1]->X()+0.5*SSDFlexBoxLength[0],
- 0.5*fgkSSDFlexWidth[0],0.,0);
- SSDFlexBoxCombiTrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
- SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
- + 0.5*SSDFlexBoxLength[1],
- fgkSSDFlexHoleWidth+0.5*SSDFlexBoxWidth[1],0.,0);
- SSDFlexBoxCombiTrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
- SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
- + fgkSSDFlexHoleLength+0.5*SSDFlexBoxLength[2],
- 0.5*SSDFlexBoxWidth[2],0.,0);
- SSDFlexBoxCombiTrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
- SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
- + fgkSSDFlexHoleLength+SSDFlexBoxLength[2]
- + 0.5*fgkSSDFlexHoleWidth,
- fgkSSDFlexHoleLength+0.5*SSDFlexBoxWidth[3],0.,0);
- SSDFlexBoxCombiTrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
- SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
- + SSDFlexBoxLength[1]+0.5*SSDFlexBoxLength[4],
- 0.5*fgkSSDFlexWidth[0],0.,0);
- SSDFlexBoxCombiTrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
- - 0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
- 0.5*fgkSSDFlexWidth[0],
- 2.*SSDFlexRadius+SSDFlexHeigth,0);
- SSDFlexBoxCombiTrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
- - SSDFlexBoxShape[6]->GetDX()
- + SSDFlexBoxShape[6]->GetDX()
- * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
- + fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
- - (SSDFlexRadiusMax-SSDFlexRadius-0.5*SSDFlexHeigth)
- * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
- 0.5*fgkSSDFlexWidth[0],SSDFlexBoxShape[6]->GetDX()
- *TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
- + SSDFlexHeigth+2.*SSDFlexRadius+(SSDFlexRadiusMax
- - SSDFlexRadius-0.5*SSDFlexHeigth)
- * TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
- new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
- SSDFlexBoxCombiTrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
- SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
- + fgkSSDFlexHoleLength+1.5*SSDFlexBoxLength[2]
- + SSDFlexBoxLength[3],
- 0.5*SSDFlexBoxWidth[2],0.,0);
- ////////////////////////////
- //SSDFlex Box Shape Assembly
- ////////////////////////////
- SSDFlexVolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
- TGeoVolume* SSDFlexBox[SSDFlexBoxNumber+1];
- TGeoVolume* SSDEndFlex = GetSSDEndFlex(SSDFlexBoxLength[6],SSDFlexHeigth);
- TGeoHMatrix* SSDEndFlexHMatrix = new TGeoHMatrix();
- TGeoRotation* SSDEndFlexRot= new TGeoRotation("SSDEndFlexRot",180.,0.,0);
- SSDEndFlexHMatrix->MultiplyLeft(SSDEndFlexRot);
- SSDEndFlexHMatrix->MultiplyLeft(SSDFlexBoxCombiTrans[6]);
- char SSDFlexBoxName[30];
- for(Int_t i=0; i<SSDFlexBoxNumber+1; i++){
- sprintf(SSDFlexBoxName,"SSDFlexBox%i",i!=SSDFlexBoxNumber?i+1:7);
- if(i==6){SSDFlexVolume[2]->AddNode(SSDEndFlex,1,SSDEndFlexHMatrix);}
- else{
- SSDFlexBox[i] = new TGeoVolume(SSDFlexBoxName,SSDFlexBoxShape[i],
- SSDFlexMed);
- SSDFlexBox[i]->SetLineColor(SSDFlexColor);
- SSDFlexVolume[2]->AddNode(SSDFlexBox[i],1,SSDFlexBoxCombiTrans[i]);}
- }
- //////////////////////
- //SSDFlex Construction
- //////////////////////
- TGeoVolume* SSDFlex = new TGeoVolumeAssembly("SSDFlex");
- for(Int_t i =0; i<SSDFlexVolumeNumber; i++) SSDFlex->AddNode(SSDFlexVolume[i],1);
- return SSDFlex;
-}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength,
- Double_t SSDFlexHeigth){
- /////////////////////////////////////////
- // Setting Display Color, Media and Index
- /////////////////////////////////////////
- Int_t SSDFlexColor;
- SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
- TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
- fgkSSDKaptonFlexMedium);
- ////////////////////////
- const Int_t SSDEndFlexBoxNumber = 5;
- TGeoBBox* SSDEndFlexBBoxShape[SSDEndFlexBoxNumber];
- SSDEndFlexBBoxShape[0] = new TGeoBBox("SSDFlexBoxShape1",
- 0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
- 0.5*SSDFlexHeigth);
- SSDEndFlexBBoxShape[1] = new TGeoBBox("SSDFlexBoxShape2",
- 0.5*fgkSSDEndFlexCompLength[1],
- 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
- 0.5*SSDFlexHeigth);
- SSDEndFlexBBoxShape[2] = new TGeoBBox("SSDFlexBoxShape3",
- 0.5*fgkSSDEndFlexCompLength[2],
- 0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
- 0.5*SSDFlexHeigth);
- SSDEndFlexBBoxShape[3] = new TGeoBBox("SSDFlexBoxShape4",
- 0.5*fgkSSDEndFlexCompLength[3],
- 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
- 0.5*SSDFlexHeigth);
- SSDEndFlexBBoxShape[4] = new TGeoBBox("SSDFlexBoxShape5",
- 0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
- 0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
- 0.5*SSDFlexHeigth);
- TGeoVolume* SSDEndFlexBBox[SSDEndFlexBoxNumber];
- char SSDEndFlexBBoxName[30];
- for(Int_t i=0; i<SSDEndFlexBoxNumber; i++){
- sprintf(SSDEndFlexBBoxName,"SSDEndFlexBBox%i",i+1);
- SSDEndFlexBBox[i] = new TGeoVolume(SSDEndFlexBBoxName,
- SSDEndFlexBBoxShape[i],
- SSDFlexMed);
- SSDEndFlexBBox[i]->SetLineColor(SSDFlexColor);
- }
- TGeoVolume* SSDEndFlex = new TGeoVolumeAssembly("SSDEndFlex");
- Double_t PartialSumLength = 0.;
- for(Int_t i=0; i<SSDEndFlexBoxNumber+1; i++) PartialSumLength += fgkSSDEndFlexCompLength[i];
- Double_t ReferenceLength = SSDEndFlexLength-PartialSumLength;
- SSDEndFlex->AddNode(SSDEndFlexBBox[0],1);
- SSDEndFlex->AddNode(SSDEndFlexBBox[1],1,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + 0.5*fgkSSDEndFlexCompLength[1],
- 0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[1]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[1],2,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + 0.5*fgkSSDEndFlexCompLength[1],
- - 0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[1]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[2],1,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
- + 0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[2]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[2],2,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
- - 0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[2]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[3],1,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
- + 0.5*fgkSSDEndFlexCompLength[3],
- + 0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[3]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[3],2,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
- + 0.5*fgkSSDEndFlexCompLength[3],
- - 0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[3]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[4],1,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
- + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
- + 0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[4]->GetDY(),
- 0.));
- SSDEndFlex->AddNode(SSDEndFlexBBox[4],2,new TGeoTranslation(
- - 0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
- + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
- + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
- + fgkSSDEndFlexCompLength[5]),
- - 0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[4]->GetDY(),
- 0.));
- return SSDEndFlex;
+ ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
+ ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
+ - ssdflexboxlength[1];
+ Double_t ssdflexboxwidth[kssdflexboxnumber];
+ ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
+ ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
+ ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
+ ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
+ ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ xmothervertex[0] = 0.0;
+ xmothervertex[1] = xmothervertex[0];
+ xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
+ xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
+ + ssdflexboxlength[4];
+ xmothervertex[4] = xmothervertex[3];
+ xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
+ xmothervertex[6] = xmothervertex[5];
+ xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
+ xmothervertex[8] = xmothervertex[7];
+ xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
+ xmothervertex[10] = xmothervertex[9];
+ xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
+ xmothervertex[12] = xmothervertex[11];
+ xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
+ xmothervertex[14] = xmothervertex[13];
+ xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
+ xmothervertex[16] = xmothervertex[15];
+ ymothervertex[0] = 0.0;
+ ymothervertex[1] = fgkSSDFlexWidth[1];
+ ymothervertex[2] = fgkSSDFlexWidth[0];
+ ymothervertex[3] = ymothervertex[2];
+ ymothervertex[4] = ymothervertex[0];
+ ymothervertex[5] = ymothervertex[4];
+ ymothervertex[6] = ssdflexboxwidth[2];
+ ymothervertex[7] = ymothervertex[6];
+ ymothervertex[8] = ymothervertex[0];
+ ymothervertex[9] = ymothervertex[8];
+ ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
+ ymothervertex[11] = ymothervertex[10];
+ ymothervertex[12] = ymothervertex[0];
+ ymothervertex[13] = ymothervertex[12];
+ ymothervertex[14] = ymothervertex[7];
+ ymothervertex[15] = ymothervertex[14];
+ ymothervertex[16] = ymothervertex[0];
+ /////////////////////////////////////////////////////////////
+ // First Mother Volume containing SSDFlex
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
+ ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
+ ymothervertex);
+ ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
+ ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
+ TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
+ fSSDAir);
+ /////////////////////////////////////////////////////////////
+ // SSDFlex Layer Shapes
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<kssdflexlayernumber; i++){
+ ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
+ ymothervertex);
+ ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
+ ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
+ }
+ /////////////////////////////////////
+ // Setting Layers into Mother Volume
+ /////////////////////////////////////
+ Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
+ TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
+ fSSDKaptonFlexMedium};
+ const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
+ "AlFlexLay2","KaptonFlexLay2"};
+ TGeoVolume* ssdflex[2*kssdflexlayernumber];
+ TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
+ for(Int_t i=0; i<2*kssdflexlayernumber; i++){
+ ssdflex[i] = new TGeoVolume(ssdflexname[i],
+ i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
+ i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
+ ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
+ ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
+ + fgkSSDFlexHeight[1]));
+ ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
+ }
+ //ssdflexmother->CheckOverlaps(0.01);
+ return ssdflexmother;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* SSDFlexAssembly = new TGeoVolumeAssembly("SSDFlexAssembly");
- const Int_t SSDFlexLayerNumber = 4;
- Double_t SSDFlexHeight[SSDFlexLayerNumber];
- Double_t SSDFlexRadius[SSDFlexLayerNumber];
- TGeoTranslation* SSDFlexTrans[SSDFlexLayerNumber];
- for(Int_t i=0; i<SSDFlexLayerNumber; i++){
- SSDFlexHeight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
- SSDFlexRadius[i] = (i==0 ? fgkSSDStiffenerHeight : SSDFlexRadius[i-1]
- + SSDFlexHeight[i-1]);
- SSDFlexTrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(SSDFlexHeight[0]
- + SSDFlexHeight[1]));
- SSDFlexAssembly->AddNode(GetSSDFlex(SSDFlexRadius[i],SSDFlexHeight[i]),i+1,
- SSDFlexTrans[i]);
- }
- return SSDFlexAssembly;
+TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
+ /////////////////////////////////////////////////////////////
+ // Method generating SSD End Flex
+ /////////////////////////////////////////
+ Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
+ / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
+ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
+ * TMath::DegToRad()*ssdflexradiusmax
+ - fgkSSDFlexLength[2]-TMath::Pi()
+ * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
+ const Int_t knedges = 20;
+ const Int_t karcnumber = 2;
+ TVector3* vertexposition[karcnumber*(knedges+1)];
+ Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
+ Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
+ Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
+ Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
+ - 90.0*TMath::DegToRad()};
+ TVector3* referencetrans[karcnumber];
+ referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
+ + radius[0]*SinD(2.*fgkSSDFlexAngle),
+ radius[0]);
+ referencetrans[1] = new TVector3(referencetrans[0]->X()
+ + fgkSSDFlexLength[2],
+ - fgkSSDStiffenerHeight);
+for(Int_t i=0; i<karcnumber; i++){
+ for(Int_t j=0; j<knedges+1; j++){
+ vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
+ radius[i]*SinD(angle[i]));
+ angle[i] += deltangle[i]*(1.0-2.0*i);
+ }
+ }
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ const Int_t kendflexlayernumber = 4;
+ const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
+ TVector3** vertex[kendflexlayernumber];
+ for(Int_t i=0; i<kendflexlayernumber; i++)
+ vertex[i] = new TVector3*[kendflexvertexnumber];
+ TVector3* transvector[kendflexlayernumber+1];
+ TVector3* deltatransvector = new TVector3();
+ for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
+ transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
+ + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
+ for(Int_t i=1; i<kendflexlayernumber+1; i++){
+ deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
+ * CosD(fgkSSDFlexAngle),
+ (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
+ * SinD(fgkSSDFlexAngle),0.0);
+ *transvector[i] = *transvector[i-1]+*deltatransvector;
+ }
+ Double_t ratioradius[karcnumber][kendflexlayernumber+1];
+ ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
+ for(Int_t i=0; i<karcnumber; i++){
+ for(Int_t j=1; j<kendflexlayernumber+1; j++){
+ ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
+ * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
+ /radius[i];
+ }
+ }
+ for(Int_t i=0; i<kendflexlayernumber; i++){
+ vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
+ vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
+ for(Int_t j=0; j<karcnumber*(knedges+1); j++){
+ if(j<(knedges+1)){
+ vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
+ vertexposition[j]->Y()*ratioradius[0][i+1]);
+ vertex[i][j+2]->RotateZ(referenceangle[0]);
+ *vertex[i][j+2] += *referencetrans[0];
+ vertex[i][4*(knedges+1)-j+1] =
+ new TVector3(vertexposition[j]->X()*ratioradius[0][i],
+ vertexposition[j]->Y()*ratioradius[0][i]);
+ vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
+ *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
+ }
+ else{
+
+ vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
+ vertexposition[j]->Y()*ratioradius[1][i+1]);
+ vertex[i][j+2]->RotateZ(referenceangle[1]);
+ *vertex[i][j+2] += *referencetrans[1];
+ vertex[i][4*(knedges+1)-j+1] =
+ new TVector3(vertexposition[j]->X()*ratioradius[1][i],
+ vertexposition[j]->Y()*ratioradius[1][i]);
+ vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
+ *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
+ }
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ // First Mother Volume containing SSDEndFlex
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
+ Double_t xmothervertex[kendflexvertexnumber];
+ Double_t ymothervertex[kendflexvertexnumber];
+ xmothervertex[0] = vertex[0][0]->X();
+ ymothervertex[0] = vertex[0][0]->Y();
+ for(Int_t i=1; i<kendflexvertexnumber; i++){
+ if(i<2*(knedges+1)+2){
+ xmothervertex[i] = vertex[3][i]->X();
+ ymothervertex[i] = vertex[3][i]->Y();
+ }
+ else{
+ xmothervertex[i] = vertex[0][i]->X();
+ ymothervertex[i] = vertex[0][i]->Y();
+ }
+ }
+ ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
+ xmothervertex,ymothervertex);
+ ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
+ ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
+ TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
+ ssdendflexmothershape,fSSDAir);
+ //////////////////////////////////////
+ // End Flex TGeoXtru Layer Definition
+ //////////////////////////////////////
+ TGeoXtru* ssdendflexshape[kendflexlayernumber];
+ TGeoVolume* ssdendflex[kendflexlayernumber];
+ for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
+ Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
+ Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
+ Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
+ TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
+ fSSDKaptonFlexMedium};
+ const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
+ "AlEndFlexLay2","KaptonEndFlexLay2"};
+ for(Int_t i=0; i<kendflexlayernumber; i++){
+ for(Int_t j=0; j<4*(knedges+1)+2; j++){
+ xvertex[i][j] = vertex[i][j]->X();
+ yvertex[i][j] = vertex[i][j]->Y();
+ }
+ ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
+ ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
+ ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
+ ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
+ i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
+ ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
+ ssdendflexmother->AddNode(ssdendflex[i],1);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
+ for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
+ for(Int_t i=0; i<kendflexlayernumber; i++){
+ for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
+ delete [] vertex[i];
+ }
+ for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
+ delete deltatransvector;
+ /////////////////////////////////////////////////////////////
+ //ssdendflexmother->CheckOverlaps(0.01);
+ return ssdendflexmother;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t SSDCoolingBlockTransNumber = 2;
- Double_t SSDCoolingBlockTransVector[SSDCoolingBlockTransNumber] =
- {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
- fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - fgkSSDCoolingBlockWidth};
- TGeoVolume* SSDCoolingBlock = GetSSDCoolingBlock();
- TGeoVolume* SSDCoolingBlockAssembly =
- new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
- for(Int_t i=0; i<SSDCoolingBlockTransNumber; i++)
- for(Int_t j=0; j<SSDCoolingBlockTransNumber; j++)
- SSDCoolingBlockAssembly->AddNode(SSDCoolingBlock,
- SSDCoolingBlockTransNumber*i+j+1,
- new TGeoTranslation(i*SSDCoolingBlockTransVector[0],
- j*SSDCoolingBlockTransVector[1],0.));
- return SSDCoolingBlockAssembly;
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Mounting Block
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 8;
+ Double_t xvertex[kvertexnumber];
+ Double_t yvertex[kvertexnumber];
+ xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
+ xvertex[1] = xvertex[0];
+ xvertex[2] = -xvertex[0];
+ xvertex[3] = xvertex[2];
+ xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
+ - fgkSSDMountingBlockLength[2]);
+ xvertex[5] = xvertex[4];
+ xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
+ - 0.5*fgkSSDMountingBlockScrewHoleEdge
+ - fgkSSDMountingBlockScrewHoleRadius[0];
+ xvertex[7] = xvertex[6];
+ yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
+ + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
+ yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
+ yvertex[2] = yvertex[1];
+ yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
+ yvertex[4] = yvertex[3];
+ yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
+ - fgkSSDMountingBlockHeight[0];
+ yvertex[6] = yvertex[5];
+ yvertex[7] = yvertex[0];
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Mounting Block Part
+ ///////////////////////////////////////////////////////////////////////
+ TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
+ ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
+ ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
+ ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
+ TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
+ ssdmountingblockshape,
+ fSSDMountingBlockMedium);
+ ssdmountingblock->SetLineColor(fColorG10);
+ TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
+ mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
+ TGeoRotation* mountingblockrot = new TGeoRotation();
+ mountingblockrot->SetAngles(90.,180.,-90.);
+ mountingblockcombitrans->SetRotation(*mountingblockrot);
+ /////////////////////////////////////////////////////////////
+ // Generating the Mounting Block Screw Vertices
+ /////////////////////////////////////////////////////////////
+ const Int_t kscrewvertexnumber = 15;
+ Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
+ - fgkSSDMountingBlockScrewHoleEdge)
+ / fgkSSDMountingBlockScrewHoleRadius[0])
+ * TMath::RadToDeg();
+ Double_t phi0 = 90.+alpha;
+ Double_t phi = 270.-2*alpha;
+ Double_t deltaphi = phi/kscrewvertexnumber;
+ TVector3* screwvertex[kscrewvertexnumber+1];
+ for(Int_t i=0; i<kscrewvertexnumber+1; i++)
+ screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
+ *CosD(phi0+i*deltaphi),
+ fgkSSDMountingBlockScrewHoleRadius[0]
+ *SinD(phi0+i*deltaphi));
+ Double_t xscrewvertex[kscrewvertexnumber+6];
+ Double_t yscrewvertex[kscrewvertexnumber+6];
+ xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
+ yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
+ - fgkSSDMountingBlockScrewHoleEdge);
+ xscrewvertex[1] = xscrewvertex[0];
+ yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
+ xscrewvertex[2] = screwvertex[0]->X();
+ yscrewvertex[2] = yscrewvertex[1];
+ for(Int_t i=0; i<kscrewvertexnumber+1; i++){
+ xscrewvertex[i+3] = screwvertex[i]->X();
+ yscrewvertex[i+3] = screwvertex[i]->Y();
+ }
+ xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
+ yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
+ xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
+ yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
+ TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
+ ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
+ ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
+ ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]);
+ TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
+ ssdmountingblockscrewshape,
+ fSSDMountingBlockMedium);
+ ssdmountingblockscrew->SetLineColor(fColorG10);
+ TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
+ for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
+ ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
+ - yscrewvertex[1],
+ 0.5*fgkSSDMountingBlockHeight[0]
+ - fgkSSDMountingBlockHeight[2]
+ + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]
+ - yvertex[0]));
+ ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
+ -0.5*fgkSSDMountingBlockScrewHoleEdge,
+ yscrewvertex[1]
+ -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
+ +fgkSSDMountingBlockHeight[2]
+ -yvertex[0]));
+ ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
+ yscrewvertex[1],
+ - 0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]
+ - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]
+ - yvertex[0]));
+ ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
+ yscrewvertex[1],
+ - yscrewvertex[1]
+ + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]
+ - yvertex[0]));
+ TGeoRotation* ssdmountingblockscrewrot[4];
+ for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
+ ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
+ ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
+ ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
+ for(Int_t i=1; i<4; i++)
+ ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
+ TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
+ ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
+ TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
+ ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
+ + xvertex[0],yscrewvertex[1]
+ - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
+ + fgkSSDMountingBlockHeight[2]
+ - yvertex[0]),0.);
+ TGeoHMatrix* ssdmountingblockscrewmatrix[4];
+ for(Int_t i=0; i<4; i++){
+ ssdmountingblockscrewmatrix[i] =
+ new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
+ ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
+ }
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXtru for Mother Volume
+ ///////////////////////////////////////////////////////////////////////
+ const Int_t kvertexmothernumber = 12;
+ Double_t xmothervertex[kvertexmothernumber];
+ Double_t ymothervertex[kvertexmothernumber];
+ for(Int_t i=0; i<6; i++){
+ xmothervertex[i] = xvertex[i];
+ ymothervertex[i] = yvertex[i];
+ }
+ xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
+ ymothervertex[6] = ymothervertex[5];
+ xmothervertex[7] = xmothervertex[6];
+ ymothervertex[7] = ymothervertex[4];
+ xmothervertex[8] = xmothervertex[7]
+ + 0.5*(fgkSSDMountingBlockLength[1]
+ - fgkSSDMountingBlockLength[2]);
+ ymothervertex[8] = ymothervertex[4];
+ xmothervertex[9] = xmothervertex[8];
+ ymothervertex[9] = ymothervertex[2];
+ xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
+ ymothervertex[10] = ymothervertex[1];
+ xmothervertex[11] = xmothervertex[10];
+ ymothervertex[11] = ymothervertex[0];
+ TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
+ ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
+ ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
+ ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
+ TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
+ ssdmountingblockmothershape,
+ fSSDAir);
+ /////////////////////////////////////////////////////////////
+ // Placing the Volumes into Mother Volume
+ /////////////////////////////////////////////////////////////
+ ssdmountingblockmother->AddNode(ssdmountingblock,1);
+ ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
+ for(Int_t i=0; i<4; i++)
+ ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
+ ssdmountingblockscrewmatrix[i]);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete mountingblockrot;
+ for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
+ delete ssdmountingblockglobalrot;
+ delete ssdmountingblockglobaltrans;
+ /////////////////////////////////////////////////////////////
+ return ssdmountingblockmother;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
-/////////////////////////////////////////////////////////////////////////////////
- // Center Cooling Block Hole
- ////////////////////////////
- Double_t CoolingBlockHoleAngle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
- /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
- Double_t CoolingBlockHoleWidth = fgkSSDCoolingBlockWidth;
- /*TGeoTubeSeg* CoolingBlockHoleShape = */ new TGeoTubeSeg("CoolingBlockHoleShape",
- 0.,
- fgkSSDCoolingBlockHoleRadius[0],
- 0.5*CoolingBlockHoleWidth,
- 180.-CoolingBlockHoleAngle,360.+CoolingBlockHoleAngle);
- TVector3* CoolingBlockHoleVertex[3];
- CoolingBlockHoleVertex[0] = new TVector3();
- CoolingBlockHoleVertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
- * TMath::Cos((90.-CoolingBlockHoleAngle)*TMath::DegToRad()),
- fgkSSDCoolingBlockHoleRadius[0]
- * TMath::Sin((90.-CoolingBlockHoleAngle)*TMath::DegToRad()));
- CoolingBlockHoleVertex[2] = new TVector3(CoolingBlockHoleVertex[1]->X(),
- - CoolingBlockHoleVertex[1]->Y());
- /* TGeoArb8* CoolingBlockTriangleHoleShape = */
- GetTriangleShape(CoolingBlockHoleVertex,
- CoolingBlockHoleWidth,"CoolingBlockTriangleHoleShape");
- TGeoRotation* CoolingBlockHoleRot =
- new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
- CoolingBlockHoleRot->RegisterYourself();
- /* TGeoCompositeShape* CoolingTubeHoleShape = */
- new TGeoCompositeShape("CoolingTubeHoleShape",
- "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
- "CoolingBlockHoleShape");
- ///////////////////////////
- // Cooling Block Trapezoids
- ///////////////////////////
- const Int_t VertexNumber = 4;
- const Int_t TrapezoidNumber = 2;
- TVector3** CoolingBlockTrapezoidVertex[TrapezoidNumber];
- for(Int_t i = 0; i<TrapezoidNumber; i++) CoolingBlockTrapezoidVertex[i] =
- new TVector3*[VertexNumber];
- Double_t CoolingBlockComponentHeight = fgkSSDCoolingBlockHeight[0]
- - fgkSSDCoolingBlockHoleCenter
- - fgkSSDCoolingBlockHoleRadius[0]
- * TMath::Sin(CoolingBlockHoleAngle*TMath::DegToRad());
- Double_t CoolingBlockTrapezoidLength[TrapezoidNumber] =
- { fgkSSDCoolingBlockLength,
- 0.5*(fgkSSDCoolingBlockLength-2.
- * (fgkSSDCoolingBlockHoleLength[1]
- - fgkSSDCoolingBlockHoleRadius[1])
- - fgkSSDCoolingBlockHoleLength[0])};
- Double_t CoolingBlockTrapezoidHeigth[TrapezoidNumber] =
- { fgkSSDCoolingBlockHeight[0]-CoolingBlockComponentHeight
- - fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
- - fgkSSDCoolingBlockHoleRadius[1],
- CoolingBlockComponentHeight};
- Double_t CoolingBlockTrapezoidWidth[TrapezoidNumber] =
- {fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
- //////////////////////////
- //Vertex Positioning Shape
- //////////////////////////
- CoolingBlockTrapezoidVertex[0][0] = new TVector3();
- CoolingBlockTrapezoidVertex[0][1] = new TVector3(CoolingBlockTrapezoidLength[0]);
- CoolingBlockTrapezoidVertex[0][2] = new TVector3(
- 0.5*(CoolingBlockTrapezoidVertex[0][1]->X()
- - 2.*CoolingBlockTrapezoidLength[1]
- - fgkSSDCoolingBlockHoleLength[0]));
- CoolingBlockTrapezoidVertex[0][3] =
- new TVector3(CoolingBlockTrapezoidVertex[0][1]->X()
- - CoolingBlockTrapezoidVertex[0][2]->X());
- CoolingBlockTrapezoidVertex[1][0] = new TVector3();
- CoolingBlockTrapezoidVertex[1][1] = new TVector3(CoolingBlockTrapezoidLength[1]);
- CoolingBlockTrapezoidVertex[1][2] =
- new TVector3(CoolingBlockTrapezoidHeigth[1]
- / CoolingBlockTrapezoidHeigth[0]
- * CoolingBlockTrapezoidVertex[0][2]->X());
- CoolingBlockTrapezoidVertex[1][3] =
- new TVector3(CoolingBlockTrapezoidVertex[1][1]->X());
- char* CoolingBlockTrapezoidShapeName[TrapezoidNumber] =
- {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
- TGeoArb8* CoolingBlockTrapezoidShape[TrapezoidNumber];
- for(Int_t i = 0; i< TrapezoidNumber; i++) CoolingBlockTrapezoidShape[i] =
- GetArbShape(CoolingBlockTrapezoidVertex[i],
- CoolingBlockTrapezoidWidth,
- CoolingBlockTrapezoidHeigth[i],
- CoolingBlockTrapezoidShapeName[i]);
- TGeoTranslation* CoolingBlockTrapezoidTrans =
- new TGeoTranslation("CoolingBlockTrapezoidTrans",
- CoolingBlockTrapezoidVertex[0][2]->X(),
- 0.0,
- 0.5*(CoolingBlockTrapezoidHeigth[0]
- + CoolingBlockTrapezoidHeigth[1]));
- CoolingBlockTrapezoidTrans->RegisterYourself();
- TGeoCombiTrans* CoolingBlockTrapezoidCombiTrans =
- new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
- CoolingBlockTrapezoidVertex[0][3]->X(),
- fgkSSDCoolingBlockWidth,
- 0.5*(CoolingBlockTrapezoidHeigth[0]
- + CoolingBlockTrapezoidHeigth[1]),
- new TGeoRotation("",180.,0.,0.));
- CoolingBlockTrapezoidCombiTrans->RegisterYourself();
- /* TGeoCompositeShape* CoolingBlockTrapezoidCompositeShape = */
- new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
- "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
- "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans");
- /////////////////////////////
- // Cooling Block Boxes Shapes
- /////////////////////////////
- const Int_t BoxNumber = 3;
- TGeoBBox* CoolingBlockBoxShape[BoxNumber];
- CoolingBlockBoxShape[0] = new TGeoBBox("CoolingBlockBoxShape0",
- 0.5*fgkSSDCoolingBlockLength,
- 0.5*fgkSSDCoolingBlockWidth,
- 0.5*fgkSSDCoolingBlockHoleRadius[1]);
- CoolingBlockBoxShape[1] = new TGeoBBox("CoolingBlockBoxShape1",
- 0.5*(fgkSSDCoolingBlockLength
- - 2.*fgkSSDCoolingBlockHoleLength[1]),
- 0.5*fgkSSDCoolingBlockWidth,
- 0.5*fgkSSDCoolingBlockHeight[2]);
- CoolingBlockBoxShape[2] = new TGeoBBox("CoolingBlockBoxShape2",
- 0.5*fgkSSDCoolingBlockLength,
- 0.5*fgkSSDCoolingBlockWidth,
- 0.5*fgkSSDCoolingBlockHeight[1]);
- TGeoTranslation* CoolingBlockBoxTrans[BoxNumber-1];
- CoolingBlockBoxTrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
- 0.5*(fgkSSDCoolingBlockHeight[1]
- + fgkSSDCoolingBlockHoleRadius[1])
- + fgkSSDCoolingBlockHeight[2]);
- CoolingBlockBoxTrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
- 0.0,
- 0.0,
- 0.5*(fgkSSDCoolingBlockHeight[1]
- + fgkSSDCoolingBlockHeight[2]));
- for(Int_t i=0; i<BoxNumber-1; i++) CoolingBlockBoxTrans[i]->RegisterYourself();
- /* TGeoCompositeShape* CoolingBlockBoxCompositeShape = */
- new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
- "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
- "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
- ///////////////////////
- // Cooling Block Shape
- //////////////////////
- TGeoCombiTrans* CoolingTubeHoleShapeCombiTrans =
- new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
- 0.5*fgkSSDCoolingBlockLength,
- 0.5*fgkSSDCoolingBlockWidth,
- fgkSSDCoolingBlockHoleCenter,
- new TGeoRotation("",0.,90.,0.));
- CoolingTubeHoleShapeCombiTrans->RegisterYourself();
- TGeoTranslation* CoolingBlockTrapezoidCompositeShapeTrans =
- new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
- 0.0,
- 0.0,
- 0.5*CoolingBlockTrapezoidHeigth[0]+fgkSSDCoolingBlockHeight[1]+
- fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
- CoolingBlockTrapezoidCompositeShapeTrans->RegisterYourself();
- TGeoTranslation* CoolingBlockBoxCompositeShapeTrans =
- new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
- 0.5*fgkSSDCoolingBlockLength,
- 0.5*fgkSSDCoolingBlockWidth,
- 0.5*fgkSSDCoolingBlockHeight[1]);
- CoolingBlockBoxCompositeShapeTrans->RegisterYourself();
- TGeoCompositeShape* SSDCoolingBlockShape =
- new TGeoCompositeShape("SSDCoolingBlockShape",
- "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
- "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
- "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
- TGeoVolume* SSDCoolingBlock = new TGeoVolume("SSDCoolingBlock",
- SSDCoolingBlockShape,fgkSSDAlCoolBlockMedium);
- return SSDCoolingBlock;
+///////////////////////////////////////////////////////////////////////////////
+ TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
+ /////////////////////////////////////////////////////////////
+ // Method generating the Mounting Block Clip
+ /////////////////////////////////////////////////////////////
+ const Int_t kmothervertexnumber = 10;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
+ - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
+ xmothervertex[1] = xmothervertex[0];
+ xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
+ - fgkMountingBlockClibScrewRadius);
+ xmothervertex[3] = xmothervertex[2];
+ xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
+ xmothervertex[5] = xmothervertex[4];
+ xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
+ xmothervertex[7] = xmothervertex[6];
+ xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
+ xmothervertex[9] = xmothervertex[8];
+ ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
+ + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
+ ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
+ ymothervertex[2] = ymothervertex[1];
+ ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
+ - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
+ - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
+ ymothervertex[4] = ymothervertex[3];
+ ymothervertex[5] = ymothervertex[2];
+ ymothervertex[6] = ymothervertex[5];
+ ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
+ ymothervertex[8] = ymothervertex[7];
+ ymothervertex[9] = ymothervertex[0];
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Mounting Block Clip Part
+ ///////////////////////////////////////////////////////////////////////
+ TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
+ ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
+ ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
+ ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
+ TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
+ ssdmountingblockclipshape,fSSDAir);
+ ssdmountingblockclip->SetLineColor(4);
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Clip
+ ///////////////////////////////////////////////////////////////////////
+ const Int_t kclipvertexnumber = 6;
+ Double_t xclipvertex[kclipvertexnumber];
+ Double_t yclipvertex[kclipvertexnumber];
+ xclipvertex[0] = xmothervertex[0];
+ xclipvertex[1] = xclipvertex[0];
+ xclipvertex[2] = xmothervertex[6];
+ xclipvertex[3] = xclipvertex[2];
+ xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
+ xclipvertex[5] = xclipvertex[4];
+ yclipvertex[0] = ymothervertex[0];
+ yclipvertex[1] = ymothervertex[1];
+ yclipvertex[2] = yclipvertex[1];
+ yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
+ yclipvertex[4] = yclipvertex[3];
+ yclipvertex[5] = yclipvertex[0];
+ TGeoXtru* clipshape = new TGeoXtru(2);
+ clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
+ clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
+ clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
+ + fgkMountingBlockClibWidth);
+ TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
+ clip->SetLineColor(18);
+ ///////////////////////////////////////////////////////////////////////
+ // Ladder Support Piece
+ ///////////////////////////////////////////////////////////////////////
+ const Int_t ksupportvertexnumber = 4;
+ Double_t xsupportvertex[ksupportvertexnumber];
+ Double_t ysupportvertex[ksupportvertexnumber];
+ xsupportvertex[0] = xclipvertex[5];
+ xsupportvertex[1] = xsupportvertex[0];
+ xsupportvertex[2] = xmothervertex[9];
+ xsupportvertex[3] = xsupportvertex[2];
+ ysupportvertex[0] = yclipvertex[0];
+ ysupportvertex[1] = yclipvertex[3];
+ ysupportvertex[2] = ysupportvertex[1];
+ ysupportvertex[3] = ysupportvertex[0];
+ TGeoXtru* supportshape = new TGeoXtru(2);
+ supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
+ supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
+ supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
+ TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
+ support->SetLineColor(9);
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Screw
+ ///////////////////////////////////////////////////////////////////////
+ Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
+ 0.5*fgkMountingBlockClibScrewRadius};
+ Int_t edgesnumber[2] = {50,6};
+ Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
+ +0.5*(ymothervertex[3]-ymothervertex[2])};
+ TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
+ TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
+ clipscrew->SetLineColor(12);
+ TGeoRotation* screwrot = new TGeoRotation();
+ screwrot->SetAngles(0.,90.,0.);
+ TGeoTranslation* screwtrans = new TGeoTranslation();
+ screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
+ 0.5*(ymothervertex[3]+ymothervertex[2]),
+ 0.5*fgkSSDMountingBlockWidth+
+ -0.5*fgkMountingBlockSupportWidth[0]);
+ TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
+ ///////////////////////////////////////////////////////////////////////
+ // Placing the Volumes
+ ///////////////////////////////////////////////////////////////////////
+ ssdmountingblockclip->AddNode(clip,1);
+ ssdmountingblockclip->AddNode(support,1);
+ ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete screwtrans;
+ delete screwrot;
+ /////////////////////////////////////////////////////////////
+ return ssdmountingblockclip;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- TVector3* Vertex[VertexNumber];
- Vertex[0] = new TVector3();
- Vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
- Vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
- - fgkCarbonFiberJunctionEdge[1]
- * TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
- fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
- * TMath::DegToRad()));
- Vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
- * TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
- fgkCarbonFiberJunctionEdge[0]
- * TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
- TGeoArb8* CarbonFiberJunctionShapePiece =
- new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
- //////////////////////////////////
- //Setting the vertices in TGeoArb8
- //////////////////////////////////
- for(Int_t i = 0; i<2*VertexNumber; i++)
- CarbonFiberJunctionShapePiece->SetVertex(i,
- Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
- Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
- TGeoRotation* CarbonFiberJunctionRot =
- new TGeoRotation("CarbonFiberJunctionRot",
- 180.,
- 180.,
- 180-2.*fgkCarbonFiberJunctionAngle[0]);
- TGeoVolume* CarbonFiberJunctionPiece =
- new TGeoVolume("CarbonFiberJunctionPiece",
- CarbonFiberJunctionShapePiece,fgkSSDCarbonFiberMedium);
- TGeoVolume* CarbonFiberJunction =
- new TGeoVolumeAssembly("CarbonFiberJunction");
- CarbonFiberJunctionPiece->SetLineColor(fColorCarbonFiber);
- CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,1);
- CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,2,CarbonFiberJunctionRot);
- return CarbonFiberJunction;
+///////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
+ /////////////////////////////////////////////////////////////
+ // Method generating the Cooling Tube
+ /////////////////////////////////////////////////////////////
+ TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
+ new TGeoTube*[2];
+ // Ladder Cooling Tubes
+ coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+ - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
+ coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ coolingtubeshape[0][0]->GetDz());
+ coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*(fgkSSDModuleStiffenerPosition[1]
+ - fgkSSDSensorOverlap));
+ coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ coolingtubeshape[1][0]->GetDz());
+ coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*fgkSSDModuleStiffenerPosition[1]);
+ coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ coolingtubeshape[2][0]->GetDz());
+ // End Ladder Cooling Tubes
+ TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdercoolingtubeshape[i] = new TGeoTube*[2];
+ endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.50 * (fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[0]));
+ endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[0][0]->GetDz());
+ endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.50 * (fgkendladdercoolingsupportdistance[0]
+ + fgkendladdercoolingsupportdistance[1]
+ - fgkCoolingTubeSupportWidth));
+ endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[1][0]->GetDz());
+ endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - fgkEndLadderMountingBlockPosition[0]
+ - fgkendladdercoolingsupportdistance[1]
+ - fgkCoolingTubeSupportWidth));
+ endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[2][0]->GetDz());
+ endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.50 * (fgkMountingBlockToSensorSupport
+ - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
+ - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
+ + fgkSSDSensorOverlap
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ - fgkendladdercoolingsupportdistance[2]
+ - fgkEndLadderMountingBlockPosition[1]
+ - fgkCoolingTubeSupportWidth));
+ endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[3][0]->GetDz());
+ endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.50 * fgkendladdercoolingsupportdistance[2]);
+ endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[4][0]->GetDz());
+ // Ladder Cooling Tubes
+ TGeoVolume** coolingtube[fgkcoolingtubenumber];
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
+ new TGeoVolume*[2];
+ coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
+ fSSDCoolingTubePhynox);
+ coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
+ fSSDCoolingTubeWater);
+ coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
+ fSSDCoolingTubePhynox);
+ coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
+ fSSDCoolingTubeWater);
+ coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
+ fSSDCoolingTubePhynox);
+ coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
+ fSSDCoolingTubeWater);
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++){
+ coolingtube[i][0]->SetLineColor(fColorPhynox);
+ coolingtube[i][1]->SetLineColor(fColorWater);
+ }
+ // End Ladder Cooling Tubes
+ TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdercoolingtube[i] = new TGeoVolume*[2];
+ endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
+ endladdercoolingtubeshape[0][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
+ endladdercoolingtubeshape[0][1],
+ fSSDCoolingTubeWater);
+ endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
+ endladdercoolingtubeshape[1][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
+ endladdercoolingtubeshape[1][1],
+ fSSDCoolingTubeWater);
+ endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
+ endladdercoolingtubeshape[2][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
+ endladdercoolingtubeshape[2][1],
+ fSSDCoolingTubeWater);
+ endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
+ endladdercoolingtubeshape[3][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
+ endladdercoolingtubeshape[3][1],
+ fSSDCoolingTubeWater);
+ endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
+ endladdercoolingtubeshape[4][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
+ endladdercoolingtubeshape[4][1],
+ fSSDCoolingTubeWater);
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
+ endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
+ endladdercoolingtube[i][1]->SetLineColor(fColorWater);
+ }
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing Cooling Tubes
+ /////////////////////////////////////////////////////////////
+ // Ladder Cooling Tubes
+ TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++)
+ virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
+ coolingtubeshape[i][0]->GetRmax(),
+ coolingtubeshape[i][0]->GetDz());
+ TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
+ virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
+ fSSDAir);
+ virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
+ fSSDAir);
+ virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
+ fSSDAir);
+ // End Ladder Cooling Tubes
+ TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
+ endladdercoolingtubeshape[i][0]->GetRmax(),
+ endladdercoolingtubeshape[i][0]->GetDz());
+ TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
+ endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
+ endladdervirtualcoolingtubeshape[0],
+ fSSDAir);
+ endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
+ endladdervirtualcoolingtubeshape[1],
+ fSSDAir);
+ endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
+ endladdervirtualcoolingtubeshape[2],
+ fSSDAir);
+ endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
+ endladdervirtualcoolingtubeshape[3],
+ fSSDAir);
+ endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
+ endladdervirtualcoolingtubeshape[4],
+ fSSDAir);
+ TList* coolingtubelist = new TList();
+ for(Int_t i=0; i<fgkcoolingtubenumber; i++){
+ virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
+ virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
+ coolingtubelist->Add(virtualcoolingtube[i]);
+ }
+ endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
+ endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
+ coolingtubelist->Add(endladdervirtualcoolingtube[0]);
+ endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
+ endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
+ coolingtubelist->Add(endladdervirtualcoolingtube[1]);
+ endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
+ endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
+ coolingtubelist->Add(endladdervirtualcoolingtube[2]);
+ endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
+ endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
+ coolingtubelist->Add(endladdervirtualcoolingtube[3]);
+ endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
+ endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
+ coolingtubelist->Add(endladdervirtualcoolingtube[4]);
+ return coolingtubelist;
}
-/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- SetCarbonFiberJunctionCombiTransMatrix();
- TGeoVolume* CarbonFiberJunctionAssembly =
- new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
- TGeoVolume* CarbonFiberJunction =
- GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
- for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++)
- CarbonFiberJunctionAssembly->AddNode(CarbonFiberJunction,i+1,
- CarbonFiberJunctionCombiTransMatrix[i]);
- return CarbonFiberJunctionAssembly;
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
+ /////////////////////////////////////////////////////////////
+ // Method generating SSD Cooling Block
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 8;
+ ///////////////////////////////////////
+ // Vertex Positioning for TGeoXTru
+ ///////////////////////////////////////
+ TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
+ vertexposition[0] = new TVector3(0.0,0.0);
+ vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
+ vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
+ vertexposition[1]->Y());
+ vertexposition[3] = new TVector3(vertexposition[2]->X(),
+ vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
+ vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
+ vertexposition[5] = new TVector3(vertexposition[4]->X(),
+ + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
+ vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
+ vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
+ - fgkSSDCoolingBlockHoleLength[0]
+ - 4.*fgkSSDCoolingBlockHoleRadius[1]),
+ fgkSSDCoolingBlockHeight[0]
+ - fgkSSDCoolingBlockHoleRadius[1],
+ fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
+ vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
+ - fgkSSDCoolingBlockHoleLength[0]),
+ vertexposition[6]->Y());
+ Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
+ / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
+ Double_t phi = 180.-alpha;
+ Double_t psi = 180.+2.*alpha;
+ Double_t deltapsi = psi/nedges;
+ Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
+ TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
+ fgkSSDCoolingBlockHoleCenter);
+ for(Int_t i=0; i<nedges+1; i++){
+ vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
+ radius*SinD(phi+i*deltapsi));
+ *vertexposition[kvertexnumber+i] += (*transvector);
+ }
+ Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
+ for(Int_t i=0; i<kvertexnumber; i++)
+ vertexposition[kvertexnumber+nedges+1+i] =
+ GetReflection(vertexposition[kvertexnumber-1-i],param);
+ ///////////////////////////////////////////////////////////////////////
+ // TGeoXTru Volume definition for Cooling Tube Support Arc Part
+ ///////////////////////////////////////////////////////////////////////
+ TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
+ Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
+ Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
+ for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
+ xvertexpoints[i] = vertexposition[i]->X();
+ yvertexpoints[i] = vertexposition[i]->Y();
+ }
+ ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
+ yvertexpoints);
+ ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
+ ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
+ TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
+ ssdcoolingblockshape,
+ fSSDAlCoolBlockMedium);
+ ssdcoolingblock->SetLineColor(fColorAl);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete [] vertexposition;
+ delete xvertexpoints;
+ delete yvertexpoints;
+ /////////////////////////////////////////////////////////////
+ return ssdcoolingblock;
}
/////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t SSDEndLadderCableLength){
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
+ ///////////////////////////////////////////////////////
+ const Int_t kssdchipcablesnumber = 2;
+ const Int_t kssdchipcableslaynumber = 2;
+ const Int_t kvertexnumber = 4*(nedges+1)+4;
+ Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
+ Double_t ssdchipcablesradius[kssdchipcableslaynumber];
+ ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
+ - fgkSSDChipCablesHeight[0]
+ - fgkSSDChipCablesHeight[1]);
+ ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
+ Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
+ ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
+ - 2.*TMath::Pi()*ssdchipcablesradius[0]
+ - ssdchipcablesradius[0]
+ - fgkSSDChipCablesWidth[1]
+ - fgkSSDChipCablesWidth[2]);
+ ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
+ - 0.5*(fgkSSDModuleStiffenerPosition[1]
+ + fgkSSDChipCablesHeight[1]
+ + fgkSSDSensorHeight);
+ ///////////////////////////////////////////////////////
+ // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
+ ///////////////////////////////////////////////////////
+ TVector3** vertexposition[kssdchipcableslaynumber];
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
+ new TVector3*[4*(nedges+1)+4];
+ Double_t ratio[4];
+ ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
+ ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
+ / ssdchipcablesradius[0];
+ ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
+ / ssdchipcablesradius[0];
+ ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
+ + fgkSSDChipCablesHeight[1])
+ / ssdchipcablesradius[0];
+ Double_t phi = 180.;
+ Double_t deltaphi = 180./nedges;
+ Double_t angle = 0.0;
+ Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
+ Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
+ for(Int_t i=0; i<kssdchipcableslaynumber;i++){
+ xvertexpoints[i] = new Double_t[kvertexnumber];
+ yvertexpoints[i] = new Double_t[kvertexnumber];
+ }
+ TVector3* vertex = new TVector3();
+ TVector3* transvector[kssdchipcableslaynumber];
+ transvector[0] = new TVector3(fgkSSDChipWidth,
+ SSDChipCablesHeigth-ssdchipcablesradius[0]);
+ transvector[1] = new TVector3();
+ TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
+ TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
+ const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
+ {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
+ "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
+ for(Int_t k=0; k<kssdchipcablesnumber; k++){
+ transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
+ transvector[1]->SetY(ssdchipcablesradius[0]
+ + fgkSSDChipCablesHeight[0]
+ + fgkSSDChipCablesHeight[1]);
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++){
+ vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
+ - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
+ vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
+ - i*fgkSSDChipCablesHeight[0]);
+ vertexposition[i][2*(nedges+1)+2] =
+ new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
+ + fgkSSDChipCablesWidth[1]
+ + fgkSSDChipCablesWidth[2],
+ ((1.-i)*fgkSSDChipCablesHeight[i]
+ + fgkSSDChipCablesHeight[1]));
+ vertexposition[i][2*(nedges+1)+3] =
+ new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
+ vertexposition[i][2*(nedges+1)+2]->Y()
+ - fgkSSDChipCablesHeight[i]);
+ for(Int_t j=0; j<nedges+1; j++){
+ angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
+ vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
+ vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
+ vertexposition[0][(nedges+1)*i+j+2] =
+ new TVector3(*vertex+*transvector[i]);
+ vertexposition[1][(nedges+1)*i+j+2] =
+ new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
+ vertex->Y()*ratio[2*i]+transvector[i]->Y());
+ vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
+ new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
+ vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
+ new TVector3(vertex->X()*ratio[2*i+1]
+ + transvector[i]->X(),
+ vertex->Y()*ratio[2*i+1]
+ + transvector[i]->Y());
+ }
+ }
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++){
+ for(Int_t j=0; j<kvertexnumber; j++){
+ xvertexpoints[i][j] = vertexposition[i][j]->X();
+ yvertexpoints[i][j] = vertexposition[i][j]->Y();
+ }
+ ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
+ ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
+ xvertexpoints[i],yvertexpoints[i]);
+ ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
+ ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
+ ssdchipcable[kssdchipcablesnumber*k+i] =
+ new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
+ ssdchipcableshape[kssdchipcablesnumber*k+i],
+ (kssdchipcablesnumber*k+i)%2==0?
+ fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
+ ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
+ }
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++)
+ for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
+ }
+ /////////////////////////////////////////////////////////////
+ // Mother Volume definition
+ /////////////////////////////////////////////////////////////
+ Double_t ssdchipseparation = fgkSSDSensorLength
+ - 2.*fgkSSDModuleStiffenerPosition[1]
+ - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
+ - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
+ Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
+ Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
+ +fgkSSDChipCablesWidth[1]
+ +fgkSSDChipCablesWidth[2]);
+ Double_t dy = fgkSSDChipCablesLength[1];
+ Double_t dz = SSDChipCablesHeigth;
+ TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
+ TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
+ ssdchipcablesmotherbox,fSSDAir);
+ /////////////////////////////////////////////////////////////
+ // Rotation and Translation Definition for positioning
+ /////////////////////////////////////////////////////////////
+ TGeoRotation* ssdchipcablesrot[5];
+ ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
+ ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
+ ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
+ ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
+ ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
+ TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
+ 0.,0.,ssdchipcablesrot[2]);
+ ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
+ ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
+ ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
+ ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<kssdchipcableslaynumber;i++){
+ delete [] xvertexpoints[i];
+ delete [] yvertexpoints[i];
+ }
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
+ for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
+ delete vertex;
+ delete ssdchipcablesrot[0];
+ delete ssdchipcablesrot[1];
+ delete ssdchipcablesrot[3];
+ /////////////////////////////////////////////////////////////
+ return ssdchipcablesmother;
+}
+///////////////////////////////////////////////////////////////////////////////
+TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
+ /////////////////////////////////////////////////////////////
+ // SSD Chip Assembly
+ /////////////////////////////////////////////////////////////
+ TGeoVolume* ssdchipassembly = GetSSDChips();
+ TList* ssdchipsystemlist = new TList();
+ const Int_t knedges = 20;
+ const Int_t kchipsystemnumber = 2;
+ /////////////////////////////////////////////////////////////
+ // Mother Volume containing SSDChipSystem
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* chipsystemothershape[kchipsystemnumber];
+ for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
+ const Int_t kmothervertexnumber = 12;
+ Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
+ Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
+ Double_t ssdchipcablesradius[kchipsystemnumber];
+ Double_t ssdchipseparation = fgkSSDSensorLength
+ - 2.*fgkSSDModuleStiffenerPosition[1]
+ - 2.*(fgkSSDStiffenerWidth
+ - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
+ for(Int_t i=0; i<kchipsystemnumber; i++)
+ ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
+ - fgkSSDChipCablesHeight[0]
+ - fgkSSDChipCablesHeight[1]);
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
+ xmothervertex[0][1] = xmothervertex[0][0];
+ xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
+ + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
+ xmothervertex[0][3] = xmothervertex[0][2];
+ xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
+ xmothervertex[0][5] = xmothervertex[0][4];
+ xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
+ xmothervertex[0][7] = xmothervertex[0][6];
+ xmothervertex[0][8] = 0.0;
+ xmothervertex[0][9] = xmothervertex[0][8];
+ xmothervertex[0][10] = xmothervertex[0][4];
+ xmothervertex[0][11] = xmothervertex[0][10];
+ for(Int_t i=0; i<kmothervertexnumber; i++)
+ xmothervertex[1][i] = xmothervertex[0][i];
+ for(Int_t i=0; i<kchipsystemnumber; i++){
+ ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
+ - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
+ ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
+ ymothervertex[i][2] = ymothervertex[i][1];
+ ymothervertex[i][3] = ymothervertex[i][0];
+ ymothervertex[i][4] = ymothervertex[i][0];
+ ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
+ ymothervertex[i][6] = ymothervertex[i][5];
+ ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
+ ymothervertex[i][8] = ymothervertex[i][7];
+ ymothervertex[i][9] = ymothervertex[i][5];
+ ymothervertex[i][10] = ymothervertex[i][5];
+ ymothervertex[i][11] = ymothervertex[i][4];
+ }
+ //////////////////////////////////////////////////////////
+ TGeoVolume* chipsystemother[kchipsystemnumber];
+ const char* chipsytemothername[kchipsystemnumber] =
+ {"SSDChipSytemother1","SSDChipSytemother2"};
+ for(Int_t i=0; i<kchipsystemnumber; i++){
+ chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
+ xmothervertex[i],ymothervertex[i]);
+ chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
+ -0.5*fgkSSDChipHeight);
+ chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
+ chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
+ chipsystemothershape[i],fSSDAir);
+ }
+ /////////////////////////////////////////////////////////////
+ // SSD Chip Cables
+ /////////////////////////////////////////////////////////////
+ TGeoVolume* ssdchipcables[kchipsystemnumber];
+ TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
+ TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
+ TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
+ //////////////////
+ for(Int_t i=0; i<kchipsystemnumber; i++){
+ ssdchipcables[i] =
+ GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
+ ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
+ ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
+ ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
+ }
+ for(Int_t i=0; i<kchipsystemnumber; i++){
+ for(Int_t j=0; j<fgkSSDChipNumber; j++){
+ ssdchipcablestrans[i][j] = new TGeoTranslation();
+ ssdchipcablesrot[i][j] = new TGeoRotation();
+ ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
+ ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
+ ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
+ + fgkSSDChipSeparationLength),
+ 0.5*fgkSSDChipWidth,
+ - 0.5*fgkSSDChipHeight
+ - fgkSSDChipCablesHeight[i+2]);
+ ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
+ ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
+ chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
+
+ }
+ chipsystemother[i]->AddNode(ssdchipassembly,i+1);
+ ssdchipsystemlist->Add(chipsystemother[i]);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<kchipsystemnumber; i++){
+ for(Int_t j=0; j<fgkSSDChipNumber; j++){
+ delete ssdchipcablesrot[i][j];
+ delete ssdchipcablestrans[i][j];
+ }
+ delete ssdchipcablesrot[i];
+ delete ssdchipcablestrans[i];
+ }
+ /////////////////////////////////////////////////////////////
+ return ssdchipsystemlist;
+}
+///////////////////////////////////////////////////////////////////////////////
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
+ /////////////////////////////////////////////////////////////
+ // SSD Chip Assembly Generation
+ /////////////////////////////////////////////////////////////
+ const Int_t kssdchiprownumber = 2;
+ TGeoBBox* ssdchipcompshape[2];
+ ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
+ 0.5*fgkSSDChipLength,
+ 0.5*fgkSSDChipWidth,
+ 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
+ ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
+ 0.5*fgkSSDChipLength,
+ 0.5*fgkSSDChipWidth,
+ 0.5*fgkSSDChipGlueHeight);
+ TGeoVolume* ssdchipcomp[2];
+ ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
+ ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
+ fSSDChipGlueMedium);
+ ssdchipcomp[0]->SetLineColor(fColorSilicon);
+ ssdchipcomp[1]->SetLineColor(fColorEpoxy);
+ TGeoTranslation* ssdchipcomptrans[2];
+ ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
+ ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing SSDChip
+ /////////////////////////////////////////////////////////////
+ TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
+ 0.5*fgkSSDChipWidth,
+ 0.5*fgkSSDChipHeight);
+ TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
+ Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
+ fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
+ - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
+ - 0.5*fgkSSDChipWidth)};
+ /////////////////////////////////////////////////////////////
+ // Virtual Volume containing SSDChipAssembly
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
+ const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
+ Double_t xmothervertex[kssdmothervertexnumber];
+ Double_t ymothervertex[kssdmothervertexnumber];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
+ xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
+ - ymothervertex[0];
+ xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
+ ymothervertex[2] = ymothervertex[1];
+ xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
+ xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
+ ymothervertex[4] = ymothervertex[0];
+ xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
+ xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
+ + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
+ ymothervertex[6] = ymothervertex[5];
+ xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
+ - fgkSSDChipWidth;
+ xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
+ ymothervertex[8] = ymothervertex[7];
+ xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
+ ymothervertex[9] = ymothervertex[6];
+ xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
+ xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
+ //////////////////////////////////////////////////////////
+ ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
+ xmothervertex,ymothervertex);
+ ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
+ ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
+ TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
+ ssdchipmothershape,fSSDAir);
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<kssdchiprownumber; i++)
+ for(Int_t j=0; j<fgkSSDChipNumber; j++)
+ ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
+ new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
+ return ssdchipmother;
+}
/////////////////////////////////////////////////////////////////////////////////
-const Int_t LadderCableSegmentNumber = 2;
-/////////////////////////////////////////
-// LadderSegmentBBox Volume
-/////////////////////////////////////////
- TGeoBBox* LadderCableSegmentBBoxShape[LadderCableSegmentNumber];
- const char* LadderCableSegmentBBoxShapeName[LadderCableSegmentNumber] =
+TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
+ /////////////////////////////////////////////////////////////
+ // Method returning a List containing pointers to Ladder Cable Volumes
+ /////////////////////////////////////////////////////////////
+ const Int_t kladdercablesegmentnumber = 2;
+ /////////////////////////////////////////
+ // LadderSegmentBBox Volume
+ /////////////////////////////////////////
+ TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
+ const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
- for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderCableSegmentBBoxShape[i] =
- new TGeoBBox(LadderCableSegmentBBoxShapeName[i],
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
+ new TGeoBBox(laddercablesegmentbboxshapename[i],
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
0.5*fgkSSDFlexHeight[i]);
- const char* LadderCableSegmentBBoxName[LadderCableSegmentNumber] =
+ const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
{"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
- TGeoVolume* LadderCableSegmentBBox[LadderCableSegmentNumber];
- for(Int_t i=0; i<LadderCableSegmentNumber; i++){
- LadderCableSegmentBBox[i] =
- new TGeoVolume(LadderCableSegmentBBoxName[i],
- LadderCableSegmentBBoxShape[i],
- (i==0?fgkSSDAlTraceLadderCableMedium:
- fgkSSDKaptonLadderCableMedium));
- LadderCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl :
+ TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++){
+ laddercablesegmentbbox[i] =
+ new TGeoVolume(laddercablesegmentbboxname[i],
+ laddercablesegmentbboxshape[i],
+ (i==0?fSSDAlTraceLadderCableMedium:
+ fSSDKaptonLadderCableMedium));
+ laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
fColorPolyhamide);
}
- TGeoTranslation* LadderCableSegmentBBoxTrans[LadderCableSegmentNumber];
- LadderCableSegmentBBoxTrans[0] =
+ TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
+ laddercablesegmentbboxtrans[0] =
new TGeoTranslation("LadderCableSegmentBBoxTrans1",
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
0.5*fgkSSDFlexHeight[0]);
- LadderCableSegmentBBoxTrans[1] =
+ laddercablesegmentbboxtrans[1] =
new TGeoTranslation("LadderCableSegmentBBoxTrans2",
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
fgkSSDFlexHeight[0]
+0.5*fgkSSDFlexHeight[1]);
- TGeoVolume* LadderCableSegmentBBoxAssembly =
+ TGeoVolume* laddercablesegmentbboxassembly =
new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
- for(Int_t i=0; i<LadderCableSegmentNumber; i++)
- LadderCableSegmentBBoxAssembly->AddNode(LadderCableSegmentBBox[i],1,
- LadderCableSegmentBBoxTrans[i]);
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++)
+ laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
+ laddercablesegmentbboxtrans[i]);
/////////////////////////////////////////
// LadderSegmentArb8 Volume
/////////////////////////////////////////
- const Int_t VertexNumber = 4;
- TVector3** LadderCableSegmentVertexPosition[LadderCableSegmentNumber];
- for(Int_t i = 0; i<LadderCableSegmentNumber; i++) LadderCableSegmentVertexPosition[i] =
- new TVector3*[VertexNumber];
+ const Int_t kvertexnumber = 4;
+ TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
+ for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
+ new TVector3*[kvertexnumber];
//Shape Vertex Positioning
- for(Int_t i=0; i<LadderCableSegmentNumber; i++){
- LadderCableSegmentVertexPosition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
- LadderCableSegmentVertexPosition[i][1] = new TVector3(fgkSSDLadderCableWidth,
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++){
+ laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
+ laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
i*fgkSSDFlexHeight[0]);
- LadderCableSegmentVertexPosition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
+ laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
+ fgkSSDFlexHeight[1]
+ i*fgkSSDFlexHeight[0]);
- LadderCableSegmentVertexPosition[i][3] =
- new TVector3(LadderCableSegmentVertexPosition[i][1]->X(),
- LadderCableSegmentVertexPosition[i][2]->Y());
+ laddercablesegmentvertexposition[i][3] =
+ new TVector3(laddercablesegmentvertexposition[i][1]->X(),
+ laddercablesegmentvertexposition[i][2]->Y());
}
- Double_t LadderCableSegmentWidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
+ Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
{fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
- char* LadderCableSegmentArbShapeName[LadderCableSegmentNumber] =
+ char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
- TGeoArb8* LadderCableSegmentArbShape[LadderCableSegmentNumber];
- for(Int_t i = 0; i< LadderCableSegmentNumber; i++) LadderCableSegmentArbShape[i] =
- GetArbShape(LadderCableSegmentVertexPosition[i],
- LadderCableSegmentWidth[i],
+ TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
+ for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
+ GetArbShape(laddercablesegmentvertexposition[i],
+ laddercablesegmentwidth[i],
fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
- LadderCableSegmentArbShapeName[i]);
- const char* LadderCableSegmentArbName[LadderCableSegmentNumber] =
+ laddercablesegmentarbshapename[i]);
+ const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
{"LadderCableSegmentArb1","LadderCableSegmentArb2"};
- TGeoVolume* LadderCableSegmentArb[LadderCableSegmentNumber];
- for(Int_t i=0; i<LadderCableSegmentNumber; i++){
- LadderCableSegmentArb[i] =
- new TGeoVolume(LadderCableSegmentArbName[i],
- LadderCableSegmentArbShape[i],
- (i==0?fgkSSDAlTraceLadderCableMedium:
- fgkSSDKaptonLadderCableMedium));
- LadderCableSegmentArb[i]->SetLineColor(i==0 ? fColorAl :
+ TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++){
+ laddercablesegmentarb[i] =
+ new TGeoVolume(laddercablesegmentarbname[i],
+ laddercablesegmentarbshape[i],
+ (i==0?fSSDAlTraceLadderCableMedium:
+ fSSDKaptonLadderCableMedium));
+ laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
fColorPolyhamide);
}
- TGeoRotation* LadderCableSegmentArbRot[LadderCableSegmentNumber];
- LadderCableSegmentArbRot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
+ TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
+ laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
90.,90,-90.);
- LadderCableSegmentArbRot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
+ laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
0.,90.,0.);
- TGeoCombiTrans* LadderCableSegmentArbCombiTrans =
+ TGeoCombiTrans* laddercablesegmentarbcombitrans =
new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
+ fgkSSDFlexWidth[0],0.,0.,
- new TGeoRotation((*LadderCableSegmentArbRot[1])
- *(*LadderCableSegmentArbRot[0])));
- TGeoVolume* LadderCableSegmentArbAssembly =
+ new TGeoRotation((*laddercablesegmentarbrot[1])
+ *(*laddercablesegmentarbrot[0])));
+ TGeoVolume* laddercablesegmentarbassembly =
new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
- for(Int_t i=0; i<LadderCableSegmentNumber; i++)
- LadderCableSegmentArbAssembly->AddNode(LadderCableSegmentArb[i],1,
- LadderCableSegmentArbCombiTrans);
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++)
+ laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
+ laddercablesegmentarbcombitrans);
/////////////////////////////////////////
// End Ladder Cable Volume
/////////////////////////////////////////
- TGeoBBox* LadderEndCableSegmentBBoxShape[LadderCableSegmentNumber];
- const char* LadderEndCableSegmentBBoxShapeName[LadderCableSegmentNumber] =
+ TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
+ const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
{"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
- for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderEndCableSegmentBBoxShape[i] =
- new TGeoBBox(LadderEndCableSegmentBBoxShapeName[i],
- 0.5*SSDEndLadderCableLength,
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
+ new TGeoBBox(ladderendcablesegmentbboxshapename[i],
+ 0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
0.5*fgkSSDFlexHeight[i]);
- const char* LadderEndCableSegmentBBoxName[LadderCableSegmentNumber] =
+ const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
{"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
- TGeoVolume* LadderEndCableSegmentBBox[LadderCableSegmentNumber];
- for(Int_t i=0; i<LadderCableSegmentNumber; i++){
- LadderEndCableSegmentBBox[i] =
- new TGeoVolume(LadderEndCableSegmentBBoxName[i],
- LadderEndCableSegmentBBoxShape[i],
- (i==0?fgkSSDAlTraceLadderCableMedium:
- fgkSSDKaptonLadderCableMedium));
- LadderEndCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl :
+ TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++){
+ ladderendcablesegmentbbox[i] =
+ new TGeoVolume(ladderendcablesegmentbboxname[i],
+ ladderendcablesegmentbboxshape[i],
+ (i==0?fSSDAlTraceLadderCableMedium:
+ fSSDKaptonLadderCableMedium));
+ ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
fColorPolyhamide);
}
- TGeoTranslation* LadderEndCableSegmentBBoxTrans[LadderCableSegmentNumber];
- LadderEndCableSegmentBBoxTrans[0] =
+ TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
+ ladderendcablesegmentbboxtrans[0] =
new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
- 0.5*SSDEndLadderCableLength,
+ 0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
0.5*fgkSSDFlexHeight[0]);
- LadderEndCableSegmentBBoxTrans[1] =
+ ladderendcablesegmentbboxtrans[1] =
new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
- 0.5*SSDEndLadderCableLength,
+ 0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
fgkSSDFlexHeight[0]
+0.5*fgkSSDFlexHeight[1]);
- TGeoVolume* LadderEndCableSegmentBBoxAssembly =
+ TGeoVolume* ladderendcablesegmentbboxassembly =
new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
- for(Int_t i=0; i<LadderCableSegmentNumber; i++)
- LadderEndCableSegmentBBoxAssembly->AddNode(LadderEndCableSegmentBBox[i],1,
- LadderEndCableSegmentBBoxTrans[i]);
+ for(Int_t i=0; i<kladdercablesegmentnumber; i++)
+ ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
+ ladderendcablesegmentbboxtrans[i]);
/////////////////////////////////////////
- TList* LadderCableSegmentList = new TList();
- LadderCableSegmentList->Add(LadderCableSegmentBBoxAssembly);
- LadderCableSegmentList->Add(LadderCableSegmentArbAssembly);
- LadderCableSegmentList->Add(LadderEndCableSegmentBBoxAssembly);
- return LadderCableSegmentList;
+ TList* laddercablesegmentlist = new TList();
+ laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
+ laddercablesegmentlist->Add(laddercablesegmentarbassembly);
+ laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
+ return laddercablesegmentlist;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t SSDEndLadderCableLength){
-/////////////////////////////////////////////////////////////////////////////////
- TList* LadderCableSegmentList = GetLadderCableSegment(SSDEndLadderCableLength);
- TGeoVolume* LadderCable = new TGeoVolumeAssembly("LadderCable");
+TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
+ /////////////////////////////////////////////////////////////
+ // Method generating Ladder Cable Volumes Assemblies
+ /////////////////////////////////////////////////////////////
+ TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
+ TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
for(Int_t i=0; i<n; i++){
- TGeoTranslation* LadderCableTrans = new TGeoTranslation(
+ TGeoTranslation* laddercabletrans = new TGeoTranslation(
i*(fgkCarbonFiberJunctionWidth),
fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
- LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(0),i+1,LadderCableTrans);
- if(i!=n-1) LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(1),i+1,LadderCableTrans);
+ laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
+ if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
}
- TGeoTranslation* EndLadderCableTrans = new TGeoTranslation("EndLadderCableTrans",
+ TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
(n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
- LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(2),1,EndLadderCableTrans);
- return LadderCable;
+ laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
+ return laddercable;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t SSDEndLadderCableLength){
-/////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* LadderCableAssembly = new TGeoVolumeAssembly("LadderCableAssembly");
- char LadderCableTransName[30];
+TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
+ /////////////////////////////////////////////////////////////
+ // Method generating Ladder Cable Volumes Assembly
+ /////////////////////////////////////////////////////////////
+ TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
+ char laddercabletransname[30];
for(Int_t i=0; i<n; i++){
- sprintf(LadderCableTransName,"LadderCableTrans%i",i+1);
- LadderCableAssembly->AddNode(GetLadderCable(n-i,SSDEndLadderCableLength),i+1,
- new TGeoTranslation(LadderCableTransName,i*fgkCarbonFiberJunctionWidth,0.,0.));
+ sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
+ laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
+ new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
}
- return LadderCableAssembly;
+ return laddercableassembly;
}
/////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t SSDEndLadderCableLength){
-/////////////////////////////////////////////////////////////////////////////////
- const Int_t LadderCableAssemblyNumber = 2;
- TGeoVolume* LadderCableAssembly = GetLadderCableAssembly(n,SSDEndLadderCableLength);
- TGeoVolume* LadderCable[LadderCableAssemblyNumber];
- char LadderCableAssemblyName[30];
- TList* LadderCableAssemblyList = new TList();
- for(Int_t i=0; i<LadderCableAssemblyNumber; i++){
- sprintf(LadderCableAssemblyName,"LadderCableAssembly%i",i+1);
- LadderCable[i] = new TGeoVolumeAssembly(LadderCableAssemblyName);
- LadderCable[i]->AddNode(LadderCableAssembly,i+1,i==0 ? NULL :
+TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
+ /////////////////////////////////////////////////////////////
+ // Method generating Ladder Cable List Assemblies
+ /////////////////////////////////////////////////////////////
+ const Int_t kladdercableassemblynumber = 2;
+ TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
+ TGeoVolume* ladderCable[kladdercableassemblynumber];
+ char laddercableassemblyname[30];
+ TList* laddercableassemblylist = new TList();
+ for(Int_t i=0; i<kladdercableassemblynumber; i++){
+ sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
+ ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
+ ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
new TGeoCombiTrans((n-1)
* fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
0.,new TGeoRotation("",180,0.,0.)));
- LadderCableAssemblyList->Add(LadderCable[i]);
+ laddercableassemblylist->Add(ladderCable[i]);
}
- return LadderCableAssemblyList;
+ return laddercableassemblylist;
}
-/////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t EndLabberCarbonFiberJunctionNumber = 2;
- TGeoVolume* EndLadderCarbonFiberJunctionAssembly[EndLabberCarbonFiberJunctionNumber];
- EndLadderCarbonFiberJunctionAssembly[0] =
- new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
- EndLadderCarbonFiberJunctionAssembly[1] =
- new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
- TGeoVolume** EndLadderCarbonFiberJunction[EndLabberCarbonFiberJunctionNumber];
- for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++)
- EndLadderCarbonFiberJunction[i] = new TGeoVolume*[2];
- for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
- EndLadderCarbonFiberJunction[i][0] =
- GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
- EndLadderCarbonFiberJunction[i][1] =
- GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetLadderSegment(){
+ /////////////////////////////////////////////////////////////
+ // Method Generating Ladder Segment Array
+ /////////////////////////////////////////////////////////////
+ fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
+ fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
+ if(!fCreateMaterials) CreateMaterials();
+ if(!fTransformationMatrices) CreateTransformationMatrices();
+ if(!fBasicObjects) CreateBasicObjects();
+ for(Int_t i=0; i<fgkladdersegmentnumber; i++){
+ // Placing Carbon Fiber Support
+ for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
+ fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
+ fcarbonfibersupportmatrix[j]);
+ fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
+ fcarbonfibersupportmatrix[j]);
}
- TList* EndLadderCarbonFiberJunctionList = new TList();
- for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
- SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
- for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
- EndLadderCarbonFiberJunctionAssembly[i]->AddNode(j==2 ?
- EndLadderCarbonFiberJunction[i][1] :
- EndLadderCarbonFiberJunction[i][0],
- j+1,EndLadderCarbonFiberJunctionCombiTransMatrix[j]);
- EndLadderCarbonFiberJunctionList->Add(EndLadderCarbonFiberJunctionAssembly[i]);
- }
- return EndLadderCarbonFiberJunctionList;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- const Int_t ShapesNumber = 2;
- TVector3** VertexPosition[ShapesNumber];
- for(Int_t i=0; i<ShapesNumber; i++) VertexPosition[i] = new TVector3*[VertexNumber];
- Double_t CarbonFiberSupportXAxisEdgeProj =
- fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
- * TMath::DegToRad());
- Double_t Theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
- / fgkCarbonFiberSupportXAxisLength);
- /////////////////////
- //Vertex Positioning
- ////////////////////
- VertexPosition[0][0] = new TVector3();
- VertexPosition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
- fgkCarbonFiberSupportYAxisLength);
- VertexPosition[0][2] = new TVector3(CarbonFiberSupportXAxisEdgeProj,
- CarbonFiberSupportXAxisEdgeProj
- * TMath::Tan(Theta));
- VertexPosition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
- - CarbonFiberSupportXAxisEdgeProj,
- fgkCarbonFiberSupportYAxisLength
- - VertexPosition[0][2]->Y());
- ////////////////////////////////////////////////////
- //Setting the parameters for Isometry Transformation
- ////////////////////////////////////////////////////
- Double_t SymmetryPlanePosition = (fgkCarbonFiberSupportYAxisLength
- + fgkCarbonFiberSupportTopEdgeDist[0]
- + fgkCarbonFiberSupportWidth);
- Double_t* param = new Double_t[4];
- param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -SymmetryPlanePosition;
- for(Int_t j=0; j<VertexNumber; j++) VertexPosition[1][j] =
- new TVector3((GetReflection(VertexPosition[0][j],param))->X(),
- (GetReflection(VertexPosition[0][j],param))->Y());
- char* CarbonFiberSupportShapeName[ShapesNumber] =
- {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
- TGeoArb8* CarbonFiberSupportShape[ShapesNumber];
- Double_t Width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
- Double_t CarbonFiberSupportHeight =
- CarbonFiberSupportXAxisEdgeProj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
- *TMath::DegToRad());
- for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberSupportShape[i] =
- GetArbShape(VertexPosition[i],Width,CarbonFiberSupportHeight,
- CarbonFiberSupportShapeName[i],i==0 ? 1: -1);
- /////////////////////////////////////
- //Setting Translations and Rotations:
- /////////////////////////////////////
- TGeoTranslation* CarbonFiberSupportTrans =
- new TGeoTranslation("CarbonFiberSupportTrans",
- 0.0,0.0,0.5*CarbonFiberSupportHeight);
- CarbonFiberSupportTrans->RegisterYourself();
- TGeoRotation* CarbonFiberCompShapeRot[2];
- CarbonFiberCompShapeRot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
- 0.0,180.0,0.0);
- CarbonFiberCompShapeRot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
- 90.,-fgkCarbonFiberTriangleAngle,-90.);
- Double_t TransVector[3] = {fgkCarbonFiberTriangleLength
- * TMath::Cos(fgkCarbonFiberTriangleAngle
- * TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
- * TMath::Sin(fgkCarbonFiberTriangleAngle
- * TMath::DegToRad())};
- TGeoCombiTrans* CarbonFiberSupportCombiTrans =
- new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
- TransVector[0],2.*SymmetryPlanePosition
- + TransVector[1],TransVector[2],
- new TGeoRotation((*CarbonFiberCompShapeRot[1])
- * (*CarbonFiberCompShapeRot[0])));
- CarbonFiberSupportCombiTrans->RegisterYourself();
-////////////////////////////////////////////////////////////////////////////////
- TGeoCompositeShape* CarbonFiberSupportCompShape =
- new TGeoCompositeShape("CarbonFiberSupportCompShape",
- "CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
- "CarbonFiberSupportShape2:CarbonFiberSupportTrans");
- TGeoVolume* CarbonFiberSupport = new TGeoVolume("CarbonFiberSupport",
- CarbonFiberSupportCompShape,fgkSSDCarbonFiberMedium);
- CarbonFiberSupport->SetLineColor(fColorCarbonFiber);
- TGeoVolume* CarbonFiberSupportAssembly =
- new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
- CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,1);
- CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,2,
- CarbonFiberSupportCombiTrans);
- return CarbonFiberSupportAssembly;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- const Int_t ShapesNumber = 2;
- Double_t Width[2] = {fgkCarbonFiberLowerSupportWidth,
- fgkCarbonFiberLowerSupportWidth};
- TVector3** VertexPosition[ShapesNumber];
- for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] =
- new TVector3*[VertexNumber];
- //First Shape Vertex Positioning
- VertexPosition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
- VertexPosition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
- - fgkCarbonFiberLowerSupportLowerLenght);
- VertexPosition[0][2] = new TVector3();
- VertexPosition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
- //Second Shape Vertex Positioning
- Double_t Theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
- - fgkCarbonFiberLowerSupportVolumePosition[0])
- / fgkCarbonFiberTriangleLength);
- VertexPosition[1][0] = new TVector3(VertexPosition[0][0]->X(),
- VertexPosition[0][0]->X()*TMath::Tan(Theta)
- + fgkCarbonFiberLowerSupportVolumePosition[0]);
- VertexPosition[1][1] = new TVector3(VertexPosition[0][1]->X(),
- VertexPosition[0][1]->X()*TMath::Tan(Theta)
- + fgkCarbonFiberLowerSupportVolumePosition[0]);
- VertexPosition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
- VertexPosition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
- fgkCarbonFiberLowerSupportVolumePosition[1]);
- char* CarbonFiberLowerSupportName[ShapesNumber] =
- {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
- TGeoArb8* CarbonFiberLowerSupportShape[ShapesNumber];
- for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberLowerSupportShape[i] =
- GetArbShape(VertexPosition[i],Width,
- fgkCarbonFiberLowerSupportHeight,
- CarbonFiberLowerSupportName[i]);
- ///////////////////////////////////////////////////////
- TGeoTranslation* CarbonFiberLowerSupportTrans[ShapesNumber];
- CarbonFiberLowerSupportTrans[0] =
- new TGeoTranslation("CarbonFiberLowerSupportTrans1",
- 0.0,
- VertexPosition[1][3]->Y()+VertexPosition[1][2]->Y(),
- 0.0);
- CarbonFiberLowerSupportTrans[1] =
- new TGeoTranslation("CarbonFiberLowerSupportTrans2",
- 0.0,
- - VertexPosition[1][3]->Y()-VertexPosition[1][2]->Y(),
- 0.0);
- for(Int_t i = 0; i< ShapesNumber; i++)
- CarbonFiberLowerSupportTrans[i]->RegisterYourself();
- ///////////////////////////////////////////////////////
- TGeoCompositeShape* CarbonFiberLowerSupportCompShape;
- if(EndLadder==false)
- CarbonFiberLowerSupportCompShape =
- new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
- "CarbonFiberLowerSupportShape2+"
- "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
- else
- if(ikind==0)
- CarbonFiberLowerSupportCompShape =
- (TGeoCompositeShape*)CarbonFiberLowerSupportShape[0];
- else
- CarbonFiberLowerSupportCompShape =
- new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
- "CarbonFiberLowerSupportShape1+"
- "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
- TGeoVolume* CarbonFiberLowerSupport = new TGeoVolume("CarbonFiberLowerSupport",
- CarbonFiberLowerSupportCompShape,fgkSSDCarbonFiberMedium);
- CarbonFiberLowerSupport->SetLineColor(fColorCarbonFiber);
- return CarbonFiberLowerSupport;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
-////////////////////////////////////////////////////////////////////////////////
- SetCarbonFiberAssemblyCombiTransMatrix();
- TGeoVolume* CarbonFiberAssemblySupport =
- new TGeoVolumeAssembly("CarbonFiberAssembly");
- TGeoVolume* CarbonFiberAssemblyVolumes[fgkCarbonFiberAssemblyCombiTransNumber];
- CarbonFiberAssemblyVolumes[0] = GetCarbonFiberJunctionAssembly();
- CarbonFiberAssemblyVolumes[1] = GetCarbonFiberSupport();
- CarbonFiberAssemblyVolumes[2] = GetCarbonFiberLowerSupport();
- for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++)
- CarbonFiberAssemblySupport->AddNode(CarbonFiberAssemblyVolumes[i],1,
- CarbonFiberAssemblyCombiTransMatrix[i]);
- return CarbonFiberAssemblySupport;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 3;
- Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
- / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
- /* TGeoTubeSeg* CoolingTubeSegShape = */
- new TGeoTubeSeg("CoolingTubeSegShape",0.0,
- fgkCoolingTubeSupportRmax,
- 0.5*fgkCoolingTubeSupportWidth,Phi,
- 360-Phi);
- /* TGeoTube* CoolingTubeHoleShape = */
- new TGeoTube("CoolingTubeHoleShape",0.0,
- fgkCoolingTubeSupportRmin,
- 0.5*fgkCoolingTubeSupportWidth);
- TVector3* VertexPosition[VertexNumber];
- ///////////////////////////
- //Shape Vertex Positioning
- ///////////////////////////
- VertexPosition[0] = new TVector3();
- VertexPosition[1] = new TVector3(fgkCoolingTubeSupportRmax
- * TMath::Cos(Phi*TMath::DegToRad()),
- fgkCoolingTubeSupportRmax
- * TMath::Sin(Phi*TMath::DegToRad()));
- VertexPosition[2] = new TVector3(VertexPosition[1]->X(),
- - VertexPosition[1]->Y());
- /* TGeoArb8* CoolingTubeTriangleShape = */ GetTriangleShape(VertexPosition,
- fgkCoolingTubeSupportWidth,
- "CoolingTubeTriangleShape");
- Double_t* BoxOrigin = new Double_t[3];
- Double_t BoxLength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
- - VertexPosition[1]->X();
- BoxOrigin[0] = VertexPosition[1]->X()+0.5*BoxLength, BoxOrigin[1] = BoxOrigin[2] = 0.;
- /* TGeoBBox* CoolingTubeBoxShape = */
- new TGeoBBox("CoolingTubeBoxShape",0.5*BoxLength,
- 0.5*fgkCoolingTubeSupportHeight,
- 0.5*fgkCoolingTubeSupportWidth,BoxOrigin);
- TGeoCompositeShape* CoolingTubeSupportShape =
- new TGeoCompositeShape("CoolingTubeSupportShape",
- "(CoolingTubeSegShape+CoolingTubeTriangleShape"
- "+CoolingTubeBoxShape)-CoolingTubeHoleShape");
- TGeoVolume* CoolingTubeSupport = new TGeoVolume("CoolingTubeSupport",
- CoolingTubeSupportShape,fgkSSDTubeHolderMedium);
- return CoolingTubeSupport;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* CoolingTubeSupportAssembly =
- new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
- TGeoVolume* CoolingTubeSupport = GetCoolingTubeSupport();
- SetCoolingTubeSupportCombiTransMatrix();
- for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++)
- CoolingTubeSupportAssembly->AddNode(CoolingTubeSupport,i+1,
- CoolingTubeSupportCombiTransMatrix[i]);
- return CoolingTubeSupportAssembly;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube(){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* CoolingTubeAssembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
- TGeoTube *CoolingTubeShape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin,
- fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
- TGeoVolume* CoolingTube = new TGeoVolume("CoolingTube",
- CoolingTubeShape,fgkSSDCoolingTubePhynox);
- TGeoTube *CoolingTubeInteriorShape = new TGeoTube("CoolingTubeInteriorShape",
- 0, fgkCoolingTubeRmin,
- fgkCoolingTubeLength/2.0);
- TGeoVolume *CoolingTubeInterior = new TGeoVolume("CoolingTubeInterior",
- CoolingTubeInteriorShape,fgkSSDCoolingTubeWater);
- CoolingTubeAssembly->AddNode(CoolingTube,1);
- CoolingTubeAssembly->AddNode(CoolingTubeInterior,2);
- return CoolingTubeAssembly;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* CoolingTubeAssembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
- TGeoVolume* CoolingTube = GetCoolingTube();
- SetCoolingTubeCombiTransMatrix();
- for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++)
- CoolingTubeAssembly->AddNode(CoolingTube,i+1,CoolingTubeTransMatrix[i]);
- return CoolingTubeAssembly;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
-////////////////////////////////////////////////////////////////////////////////
- TGeoVolume* LadderSegment = new TGeoVolumeAssembly("LadderSegment");
- TGeoVolume* LadderSegmentVolumes[fgkLadderSegmentCombiTransNumber];
- LadderSegmentVolumes[0] = GetCarbonFiberAssemblySupport();
- LadderSegmentVolumes[1] = GetSSDModule(iChipCablesHeight);
- LadderSegmentVolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
- LadderSegmentVolumes[3] = GetCoolingTubeSupportAssembly();
- LadderSegmentVolumes[4] = GetCoolingTubeAssembly();
- SetLadderSegmentCombiTransMatrix();
- for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++)
- LadderSegment->AddNode(LadderSegmentVolumes[i],1,
- LadderSegmentCombiTransMatrix[i]);
- return LadderSegment;
-}
-////////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t EndLadderSegmentNumber = 2;
- TList* EndLadderCarbonFiberJunctionList = GetEndLadderCarbonFiberJunctionAssembly();
- TGeoVolume* EndLadderSegment[EndLadderSegmentNumber];
- EndLadderSegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
- EndLadderSegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
- TGeoVolume** LadderSegmentVolumes[EndLadderSegmentNumber];
- const Int_t LadderSegmentVolumeNumber = 4;
- for(Int_t i=0; i<EndLadderSegmentNumber; i++) LadderSegmentVolumes[i] =
- new TGeoVolume*[LadderSegmentVolumeNumber];
- LadderSegmentVolumes[0][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(0);
- LadderSegmentVolumes[0][1] = GetCarbonFiberSupport();
- LadderSegmentVolumes[0][2] = GetSSDMountingBlock();
- LadderSegmentVolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
- LadderSegmentVolumes[1][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(1);
- LadderSegmentVolumes[1][1] = LadderSegmentVolumes[0][1];
- LadderSegmentVolumes[1][2] = LadderSegmentVolumes[0][2];
- LadderSegmentVolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
- TList* EndLadderSegmentList = new TList();
- for(Int_t i=0; i<EndLadderSegmentNumber; i++){
- SetEndLadderSegmentCombiTransMatrix(i);
- for(Int_t j=0; j<LadderSegmentVolumeNumber; j++)
- EndLadderSegment[i]->AddNode(LadderSegmentVolumes[i][j],1,
- EndLadderSegmentCombiTransMatrix[j]);
- EndLadderSegmentList->Add(EndLadderSegment[i]);
- }
- return EndLadderSegmentList;
+ // Placing Carbon Fiber Junction
+ for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
+ fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
+ fcarbonfiberjunctionmatrix[j]);
+ // Placing Carbon Fiber Lower Support
+ for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
+ fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
+ fcarbonfiberlowersupportrans[j]);
+ // Placing SSD Sensor Support
+ for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
+ fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
+ fssdsensorsupport[1][i],
+ j+1,fssdsensorsupportmatrix[j]);
+ // Placing SSD Cooling Tube Support
+ for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
+ fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
+ fcoolingtubesupportmatrix[j]);
+ // Placing SSD Cooling Tube
+ for(Int_t j=0; j<2; j++)
+ for(Int_t k=0; k<2; k++){
+ fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
+ fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
+ }
+ // Placing SSD Hybrid
+ switch(i){
+ case 0:
+ fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
+ fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
+ break;
+ case 1:
+ fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
+ fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
+ break;
+ }
+ // Placing Cooling Block System
+ fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
+ // Placing SSD Flex
+ for(Int_t j=0; j<fgkflexnumber; j++){
+ fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
+ fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
+ }
+ }
}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
-////////////////////////////////////////////////////////////////////////////////
- // Mounting Block Boxes Shapes
- ///////////////////////////////////////
- const Int_t MountingBlockBoxNumber = 3;
- TGeoBBox* MountingBlockBoxShape[MountingBlockBoxNumber];
- MountingBlockBoxShape[0] = new TGeoBBox("MountingBlockBoxShape0",
- 0.25*(fgkSSDMountingBlockLength[0]
- - fgkSSDMountingBlockLength[1]),
- 0.5*fgkSSDMountingBlockWidth,
- 0.5*fgkSSDMountingBlockHeight[0]);
- MountingBlockBoxShape[1] = new TGeoBBox("MountingBlockBoxShape1",
- 0.25*(fgkSSDMountingBlockLength[1]
- - fgkSSDMountingBlockLength[2]),
- 0.5*fgkSSDMountingBlockWidth,
- 0.5*(fgkSSDMountingBlockHeight[1]
- - fgkSSDMountingBlockHeight[3]));
- MountingBlockBoxShape[2] = new TGeoBBox("MountingBlockBoxShape2",
- 0.5*fgkSSDMountingBlockLength[2],
- 0.5*fgkSSDMountingBlockWidth,
- 0.5*(fgkSSDMountingBlockHeight[2]
- - fgkSSDMountingBlockHeight[3]));
- TGeoTranslation* MountingBlockBoxTrans[MountingBlockBoxNumber+2];
- MountingBlockBoxTrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
- MountingBlockBoxTrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
- MountingBlockBoxShape[0]->GetDX()
- + MountingBlockBoxShape[1]->GetDX(),
- 0.0,
- MountingBlockBoxShape[1]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]);
- MountingBlockBoxTrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
- MountingBlockBoxShape[0]->GetDX()
- + 2.*MountingBlockBoxShape[1]->GetDX()
- + MountingBlockBoxShape[2]->GetDX(),
- 0.0,
- MountingBlockBoxShape[2]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]);
- MountingBlockBoxTrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
- MountingBlockBoxShape[0]->GetDX()
- + MountingBlockBoxShape[1]->GetDX()
- + 2.*(MountingBlockBoxShape[1]->GetDX()
- + MountingBlockBoxShape[2]->GetDX()),
- 0.0,
- MountingBlockBoxShape[1]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]);
- MountingBlockBoxTrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
- 2.*(MountingBlockBoxShape[0]->GetDX()
- + 2.*MountingBlockBoxShape[1]->GetDX()
- + MountingBlockBoxShape[2]->GetDX()),
- 0.0,
- 0.0);
- for(Int_t i=0; i<MountingBlockBoxNumber+2; i++)
- MountingBlockBoxTrans[i]->RegisterYourself();
- ///////////////////////////////////////
- // Mounting Block Trapezoid Hole Shapes
- ///////////////////////////////////////
- const Int_t HoleTrapezoidVertexNumber = 4;
- TVector3* HoleTrapezoidVertex[HoleTrapezoidVertexNumber];
- HoleTrapezoidVertex[0] = new TVector3();
- HoleTrapezoidVertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
- HoleTrapezoidVertex[2] = new TVector3(*HoleTrapezoidVertex[0]);
- HoleTrapezoidVertex[3] = new TVector3(*HoleTrapezoidVertex[1]);
- Double_t HoleTrapezoidWidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
- + 2.*MountingBlockBoxShape[1]->GetDX()
- * TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
- * TMath::DegToRad()),
- fgkSSDMountingBlockHoleTrapezoidUpBasis};
- /* TGeoArb8* HoleTrapezoidShape =*/ GetArbShape(HoleTrapezoidVertex,
- HoleTrapezoidWidth,
- 2.*MountingBlockBoxShape[1]->GetDX(),
- "HoleTrapezoidShape");
- TGeoRotation* HoleTrapezoidShapeRot[2];
- HoleTrapezoidShapeRot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
- 90.,-90.,-90.);
- HoleTrapezoidShapeRot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
- -180.,0.,0.);
- TGeoCombiTrans* HoleTrapezoidShapeCombiTrans =
- new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
- MountingBlockBoxShape[0]->GetDX()
- + 3.*MountingBlockBoxShape[1]->GetDX()
- + 2.*MountingBlockBoxShape[2]->GetDX(),
- 0.5*fgkSSDMountingBlockWidth,
- - fgkSSDMountingBlockHoleTrapezoidHeight
- + 2.*MountingBlockBoxShape[1]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3],
- new TGeoRotation((*HoleTrapezoidShapeRot[1])
- * (*HoleTrapezoidShapeRot[0])));
- HoleTrapezoidShapeCombiTrans->RegisterYourself();
- ///////////////////////////////////
- // Mounting Block Screw Hole Shapes
- ///////////////////////////////////
- const Int_t MountingBlockTubeNumber = 2;
- TGeoTube* MountingBlockTubeShape[MountingBlockTubeNumber];
- MountingBlockTubeShape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
- fgkSSDMountingBlockHoleRadius,
- MountingBlockBoxShape[0]->GetDZ());
- MountingBlockTubeShape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
- fgkSSDMountingBlockHoleRadius,
- MountingBlockBoxShape[2]->GetDZ());
- TGeoTranslation* MountingBlockTubeTrans[2*MountingBlockTubeNumber];
- MountingBlockTubeTrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
- - 0.5*(fgkSSDMountingBlockLength[0]
- - fgkSSDMountingBlockHoleTubeLength[0]),
- 0.5*fgkSSDMountingBlockWidth
- - fgkSSDMountingBlockHoleTubeWidth[0],0.);
- MountingBlockTubeTrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
- - 0.5*(fgkSSDMountingBlockLength[0]
- - fgkSSDMountingBlockHoleTubeLength[0])
- + fgkSSDMountingBlockHoleTubeLength[0],
- - 0.5*fgkSSDMountingBlockWidth
- + fgkSSDMountingBlockHoleTubeWidth[0],
- 0.);
- MountingBlockTubeTrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
- - MountingBlockBoxShape[0]->GetDX()
- + 0.5*fgkSSDMountingBlockLength[0]
- - fgkSSDMountingBlockHoleTubeLength[1],
- 0.5*fgkSSDMountingBlockWidth
- - fgkSSDMountingBlockHoleTubeWidth[0],
- MountingBlockBoxShape[2]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]);
- MountingBlockTubeTrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
- - MountingBlockBoxShape[0]->GetDX()
- + 0.5*fgkSSDMountingBlockLength[0],
- - 0.5*fgkSSDMountingBlockWidth
- + fgkSSDMountingBlockHoleTubeWidth[1],
- MountingBlockBoxShape[2]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]);
- for(Int_t i=0; i<2*MountingBlockTubeNumber; i++)
- MountingBlockTubeTrans[i]->RegisterYourself();
- /* TGeoCompositeShape* MountingBlockMainShape = */
- new TGeoCompositeShape("MountingBlockMainShape",
- "MountingBlockBoxShape0:MountingBlockBoxTrans0+"
- "MountingBlockBoxShape1:MountingBlockBoxTrans1+"
- "MountingBlockBoxShape2:MountingBlockBoxTrans2+"
- "MountingBlockBoxShape1:MountingBlockBoxTrans3+"
- "MountingBlockBoxShape0:MountingBlockBoxTrans4");
- ////////////////////////////////////////////
- // Mounting Block Screw Composite Hole Shapes
- ////////////////////////////////////////////
- const Int_t MountingBlockHoleTubeSegNumber = 4;
- /* TGeoTubeSeg* MountingBlockHoleTubeSegShape = */
- new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
- 0.0,
- fgkSSDMountingBlockScrewHoleRadius[0],
- 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
- TGeoCombiTrans* MountingBlockHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
- char* MountingBlockHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
- { "MountingBlockHoleTubeSegCombiTrans0",
- "MountingBlockHoleTubeSegCombiTrans1",
- "MountingBlockHoleTubeSegCombiTrans2",
- "MountingBlockHoleTubeSegCombiTrans3"};
- for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
- MountingBlockHoleTubeSegCombiTrans[i] =
- new TGeoCombiTrans(MountingBlockHoleTubeSegCombiTransName[i],
- 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
- * TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
- 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
- * TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
- 0.0,
- new TGeoRotation("",90.*i,0.,0.));
- MountingBlockHoleTubeSegCombiTrans[i]->RegisterYourself();
- }
- TGeoBBox* MountingBlockHoleBoxShape =
- new TGeoBBox("MountingBlockHoleBoxShape",
- 0.5*fgkSSDMountingBlockScrewHoleEdge,
- 0.5*fgkSSDMountingBlockScrewHoleEdge,
- 0.5*fgkSSDMountingBlockScrewHoleHeigth);
- TGeoCompositeShape* MountingBlockScrewHole[2];
- MountingBlockScrewHole[0] =
- new TGeoCompositeShape("MountingBlockScrewHole0",
- "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
- "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
- "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
- "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
- "MountingBlockHoleBoxShape");
- /* TGeoTubeSeg* MountingBlockLowerHoleTubeSegShape = */
- new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
- 0.0,
- fgkSSDMountingBlockScrewHoleRadius[1],
- 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
- - fgkSSDMountingBlockScrewHoleHeigth
- - fgkSSDMountingBlockHeight[3]),0.,90.);
- TGeoCombiTrans* MountingBlockLowerHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
- char* MountingBlockLowerHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
- { "MountingBlockLowerHoleTubeSegCombiTrans0",
- "MountingBlockLowerHoleTubeSegCombiTrans1",
- "MountingBlockLowerHoleTubeSegCombiTrans2",
- "MountingBlockLowerHoleTubeSegCombiTrans3"};
- for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
- MountingBlockLowerHoleTubeSegCombiTrans[i] =
- new TGeoCombiTrans(MountingBlockLowerHoleTubeSegCombiTransName[i],
- 0.5*(fgkSSDMountingBlockScrewHoleEdge
- - 2.*fgkSSDMountingBlockScrewHoleRadius[1])
- * TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
- 0.5*(fgkSSDMountingBlockScrewHoleEdge
- - 2.0*fgkSSDMountingBlockScrewHoleRadius[1])
- * TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
- new TGeoRotation("",90.*i,0.,0.));
- MountingBlockLowerHoleTubeSegCombiTrans[i]->RegisterYourself();
- }
- Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
- - 2.*fgkSSDMountingBlockScrewHoleRadius[1];
- TGeoBBox* MountingBlockLowerHoleBoxShape[2];
- MountingBlockLowerHoleBoxShape[0] =
- new TGeoBBox("MountingBlockLowerHoleBoxShape0",
- 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
- 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
- 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
- - fgkSSDMountingBlockScrewHoleHeigth
- - fgkSSDMountingBlockHeight[3]));
- MountingBlockLowerHoleBoxShape[1] =
- new TGeoBBox("MountingBlockLowerHoleBoxShape1",
- 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
- 0.5*fgkSSDMountingBlockScrewHoleRadius[1],
- 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
- - fgkSSDMountingBlockScrewHoleHeigth
- - fgkSSDMountingBlockHeight[3]));
- TGeoCombiTrans* MountingBlockLowerHoleBoxCombiTrans[MountingBlockHoleTubeSegNumber];
- char* MountingBlockLowerHoleBoxCombiTransName[MountingBlockHoleTubeSegNumber] =
- { "MountingBlockLowerHoleBoxCombiTrans0",
- "MountingBlockLowerHoleBoxCombiTrans1",
- "MountingBlockLowerHoleBoxCombiTrans2",
- "MountingBlockLowerHoleBoxCombiTrans3"};
- for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
- MountingBlockLowerHoleBoxCombiTrans[i] =
- new TGeoCombiTrans(MountingBlockLowerHoleBoxCombiTransName[i],
- 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
- + fgkSSDMountingBlockScrewHoleRadius[1])
- * TMath::Cos(90*(i+1)*TMath::DegToRad()),
- 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
- + fgkSSDMountingBlockScrewHoleRadius[1])
- * TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
- new TGeoRotation("",90.*i,0.,0.));
- MountingBlockLowerHoleBoxCombiTrans[i]->RegisterYourself();
- }
- MountingBlockScrewHole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
- "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
- "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
- "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
- "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
- "MountingBlockLowerHoleBoxShape0+"
- "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
- "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
- "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
- "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
- TGeoTranslation* MountingBlockScrewHole1Trans =
- new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
- - MountingBlockLowerHoleBoxShape[0]->GetDZ()
- - MountingBlockHoleBoxShape->GetDZ());
- MountingBlockScrewHole1Trans->RegisterYourself();
- /* TGeoCompositeShape* MountingBlockHole = */
- new TGeoCompositeShape("MountingBlockHole",
- "MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
- TGeoTranslation* MountingBlockHoleTrans = new TGeoTranslation("MountingBlockHoleTrans",
- 0.5*fgkSSDMountingBlockLength[0]
- - MountingBlockBoxShape[0]->GetDZ(),
- 0.0,
- 2.*MountingBlockBoxShape[2]->GetDZ()
- - MountingBlockBoxShape[0]->GetDZ()
- + fgkSSDMountingBlockHeight[3]
- - MountingBlockHoleBoxShape->GetDZ());
- MountingBlockHoleTrans->RegisterYourself();
- TGeoCompositeShape* MountingBlockShape = new TGeoCompositeShape("MountingBlockShape",
- "MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
- "MountingBlockTubeShape0:MountingBlockTubeTrans1+"
- "MountingBlockTubeShape1:MountingBlockTubeTrans2+"
- "MountingBlockTubeShape1:MountingBlockTubeTrans3+"
- "HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
- "MountingBlockHole:MountingBlockHoleTrans)");
- TGeoVolume* SSDMountingBlock = new TGeoVolume("SSDMountingBlock",
- MountingBlockShape,fgkSSDMountingBlockMedium);
- return SSDMountingBlock;
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetEndLadderSegment(){
+ /////////////////////////////////////////////////////////////
+ // Method Generating End Ladder
+ /////////////////////////////////////////////////////////////
+ // End Ladder Carbon Fiber Junction
+ /////////////////////////////////////////////////////////////
+ fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
+ fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
+ if(!fCreateMaterials) CreateMaterials();
+ if(!fTransformationMatrices) CreateTransformationMatrices();
+ if(!fBasicObjects) CreateBasicObjects();
+ for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
+ for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
+ fendladdersegment[i]->AddNode(j==2 ?
+ fendladdercarbonfiberjunction[i][1] :
+ fendladdercarbonfiberjunction[i][0],
+ j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
+ }
+ /////////////////////////////////////////////////////////////
+ // End Ladder Carbon Fiber Support
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
+ for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
+ fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
+ fendladdercarbonfibermatrix[i][j]);
+ fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
+ fendladdercarbonfibermatrix[i][j]);
+ }
+ /////////////////////////////////////////////////////////////
+ // End Ladder Mounting Block
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
+ fendladdermountingblockcombitrans[i]);
+ /////////////////////////////////////////////////////////////
+ // End Ladder Mounting Block Clip
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
+ for(Int_t j=0; j<2; j++)
+ fendladdersegment[i]->AddNode(fendladdermountingblockclip,i+1,
+ fendladdermountingblockclipmatrix[i][j]);
+ /////////////////////////////////////////////////////////////
+ // End Ladder Lower Supports
+ /////////////////////////////////////////////////////////////
+ fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
+ fendladderlowersupptrans[0]);
+ fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
+ fendladderlowersupptrans[1]);
+ fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
+ fendladderlowersupptrans[2]);
+ /////////////////////////////////////////////////////////////
+ // End Ladder Cooling Tube Support
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<2; i++)
+ for(Int_t j=0; j<(i==0?4:2); j++)
+ fendladdersegment[i]->AddNode(fcoolingtubesupport,
+ j+1,fendladdercoolingtubesupportmatrix[i][j]);
+ /////////////////////////////////////////////////////////////
+ // End Ladder Cooling Tube Support
+ /////////////////////////////////////////////////////////////
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
+ // fendladdersegment[0]->CheckOverlaps(0.01);
+ // fendladdersegment[1]->CheckOverlaps(0.01);
}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
- TGeoVolume* Ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd"
- : "ITSssdLay6Ladd");
- TGeoVolume* LadderSegment[2];
- LadderSegment[0] = GetLadderSegment(0);
- LadderSegment[1] = GetLadderSegment(1);
- TList* EndLadderSegmentList = GetEndLadderSegment();
- Double_t BeamAxisTransVector = fgkCarbonFiberJunctionWidth;
- Int_t SSDLaySensorsNumber = (iLayer==5 ?
- fgkSSDLay5SensorsNumber :
- fgkSSDLay6SensorsNumber);
- for(Int_t i=0; i<SSDLaySensorsNumber; i++) Ladder->AddNode(i%2==0 ?
- LadderSegment[iLayer==5 ? 0 : 1] :
- LadderSegment[iLayer==5 ? 1 : 0],
- SSDLaySensorsNumber-i,new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
- BeamAxisTransVector*i,0.));
- Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(0),1,
- new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
- fgkCarbonFiberJunctionWidth*SSDLaySensorsNumber,0.));
- Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(1),1,
- new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
- 0.,0.,new TGeoRotation("",180.,0.,0.)));
+///////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetLadder(){
+ /////////////////////////////////////////////////////////////
+ // Method Generating Ladder of Layer 5 and 6
+ /////////////////////////////////////////////////////////////
+ Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
+ fgkSSDLay6SensorsNumber};
+ /////////////////////////////////////////////////////////////////////////////
+ /// Generating Ladder Mother Volume Containing Ladder
+ /////////////////////////////////////////////////////////////////////////////
+ TGeoXtru* laddershape[fgkladdernumber];
+ for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
+ const Int_t kmothervertexnumber = 8;
+ Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
+ Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
+ ///////////////////////
+ // Setting the vertices
+ ///////////////////////
+ Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
+ * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
+ xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
+ ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
+ xmothervertex[0][1] = xmothervertex[0][0];
+ ymothervertex[0][1] = 0.0;
+ xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
+ - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
+ ymothervertex[0][2] = ymothervertex[0][1];
+ ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
+ xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
+ xmothervertex[0][4] = -xmothervertex[0][3];
+ ymothervertex[0][4] = ymothervertex[0][3];
+ xmothervertex[0][5] = -xmothervertex[0][2];
+ ymothervertex[0][5] = ymothervertex[0][2];
+ xmothervertex[0][6] = -xmothervertex[0][1];
+ ymothervertex[0][6] = ymothervertex[0][1];
+ xmothervertex[0][7] = -xmothervertex[0][0];
+ ymothervertex[0][7] = ymothervertex[0][0];
+ for(Int_t i=0; i<kmothervertexnumber; i++){
+ xmothervertex[1][i] = xmothervertex[0][i];
+ ymothervertex[1][i] = ymothervertex[0][i];
+ }
+ const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
+ ymothervertex[i]);
+ laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
+ laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
+ +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
+ fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
+ fladder[i]->SetLineColor(4);
+ }
+///////////////////////////////////////////////////////////////////////////
+ if(!fCreateMaterials) CreateMaterials();
+ if(!fTransformationMatrices) CreateTransformationMatrices();
+ if(!fBasicObjects) CreateBasicObjects();
+ SetLadderSegment();
+ SetEndLadderSegment();
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
+ //////////////////////////
+ /// Placing Ladder Segment
+ //////////////////////////
+ fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
+ fladdersegment[i==0 ? 1 : 0],
+ ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
+ //////////////////////////
+ /// Placing SSD Sensor
+ //////////////////////////
+ fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
+ fssdsensormatrix[i][j]);
+ }
+ ///////////////////////////////
+ /// Placing End Ladder Segment
+ ///////////////////////////////
+ fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
+ fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
+ }
/////////////////////////////////////////////////////////////////////////////
/// Placing Ladder Cables
/////////////////////////////////////////////////////////////////////////////
- SetLadderCableCombiTransMatrix(iLayer);
- Int_t SideCableNumber[2] = {0,0};
- switch(iLayer){
- case 5:
- SideCableNumber[0] = fgkSSDLay5SensorsNumber/2+1;
- SideCableNumber[1] = SideCableNumber[0]-2;
- break;
- case 6:
- SideCableNumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
- SideCableNumber[1] = SideCableNumber[0]-1;
- break;
- }
- const Double_t* CarbonFiberToModulePosition =
- LadderSegmentCombiTransMatrix[1]->GetTranslation();
- Double_t SSDEndLadderCableLength[4];
- SSDEndLadderCableLength[0] = CarbonFiberToModulePosition[1]
+ Int_t sidecablenumber[2][2];
+ sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
+ sidecablenumber[0][1] = sidecablenumber[0][0]-2;
+ sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
+ sidecablenumber[1][1] = sidecablenumber[1][0]-1;
+ Double_t carbonfibertomoduleposition[3];
+ carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
+ carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
+ fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
+ + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
+ - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
+ - fgkSSDSensorCenterSupportThickness[0]);
+ carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
+ + 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
+ const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
+ Double_t ssdendladdercablelength[4];
+ ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
+ fgkSSDSensorLength
- fgkSSDModuleStiffenerPosition[1]
- fgkSSDStiffenerWidth
- fgkSSDFlexWidth[0]
- + fgkEndLadderCarbonFiberLowerJunctionLength[1];
- SSDEndLadderCableLength[1] = CarbonFiberToModulePosition[1]
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
+ ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
+ fgkSSDModuleStiffenerPosition[1]
+ fgkSSDStiffenerWidth
- + fgkEndLadderCarbonFiberLowerJunctionLength[1];
- SSDEndLadderCableLength[2] = SSDEndLadderCableLength[1]
+ + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
+ ssdendladdercablelength[2] = ssdendladdercablelength[1]
- fgkEndLadderCarbonFiberLowerJunctionLength[1]
- + fgkEndLadderCarbonFiberLowerJunctionLength[0];
- SSDEndLadderCableLength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
- + CarbonFiberToModulePosition[1]
+ + fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ - kendladdercablecorrection;
+ ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
+ + carbonfibertomoduleposition[1]
- fgkSSDModuleStiffenerPosition[1]
- fgkSSDStiffenerWidth)
- + fgkEndLadderCarbonFiberLowerJunctionLength[1];
- TList* LadderCableAssemblyList[4];
- const Int_t EndLadderCablesNumber = 4;
- for(Int_t i=0; i<EndLadderCablesNumber; i++){
- LadderCableAssemblyList[i] =
- GetLadderCableAssemblyList(SideCableNumber[i<2?0:1],
- SSDEndLadderCableLength[i]);
- Ladder->AddNode((TGeoVolume*)LadderCableAssemblyList[i]->At(i%2==0?0:1),
- i<2?1:2,LadderCableCombiTransMatrix[i]);
- }
- return Ladder;
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
- TGeoVolume* Layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5"
- : "ITSssdLayer6");
- TGeoVolume* Ladder = GetLadder(iLayer);
- /////////////////////////////////////////////////////
- // Setting the CombiTransformation to pass ITS center
- /////////////////////////////////////////////////////
- Double_t ITSCenterTransZ = iLayer==5 ? fgkSSDLay5LadderLength
- - fgkLay5CenterITSPosition:
- fgkSSDLay6LadderLength
- - fgkLay6CenterITSPosition;
- Double_t ITSSensorYTrans = fgkSSDModuleCoolingBlockToSensor
- + 0.5* fgkCoolingTubeSupportHeight
- -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
- - fgkSSDSensorSideSupportHeight[0]: 0.);
- TGeoRotation* ITSCenterRot[3];
- ITSCenterRot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
- ITSCenterRot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
- ITSCenterRot[2] = new TGeoRotation((*ITSCenterRot[1])*(*ITSCenterRot[0]));
- TGeoCombiTrans* ITSCenterCombiTrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
- fgkSSDMountingBlockHeight[1]+ITSSensorYTrans,
- fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - ITSCenterTransZ,ITSCenterRot[2]);
- /////////////////////////////////////////////////////
- // Setting the Ladder into the Layer
- /////////////////////////////////////////////////////
- Double_t LayLadderAnglePosition = 360./(iLayer==5 ? fgkSSDLay5LadderNumber :
- fgkSSDLay6LadderNumber);
- Int_t LayLadderNumber = iLayer==5 ? fgkSSDLay5LadderNumber :
- fgkSSDLay6LadderNumber;
- Double_t LayRadiusMin = iLayer==5 ? fgkSSDLay5RadiusMin :
- fgkSSDLay6RadiusMin;
- Double_t LayRadiusMax = iLayer==5 ? fgkSSDLay5RadiusMax :
- fgkSSDLay6RadiusMax;
- TGeoCombiTrans* LadderCombiTrans[LayLadderNumber];
- TGeoHMatrix* LadderHMatrix[LayLadderNumber];
- Double_t LayerRadius = 0.;
- char LadderCombiTransName[30], LadderRotName[30];
- for(Int_t i=0; i<LayLadderNumber;i++){
- sprintf(LadderCombiTransName,"LadderCombiTrans%i",i);
- sprintf(LadderRotName,"LaddeRot%i",i);
- switch(iLayer){
- case 5:
- LayerRadius = (i%2==0 ? LayRadiusMin: LayRadiusMax);
- break;
- case 6:
- LayerRadius = (i%2==0 ? LayRadiusMax : LayRadiusMin);
- break;
- }
- LadderCombiTrans[i] = new TGeoCombiTrans(LadderCombiTransName,
- LayerRadius * TMath::Cos((i+1)
- * LayLadderAnglePosition*TMath::DegToRad()),
- LayerRadius * TMath::Sin((i+1)
- * LayLadderAnglePosition*TMath::DegToRad()),0.,
- new TGeoRotation(LadderRotName,(i+1)
- * LayLadderAnglePosition-90,0.,0.));
- LadderHMatrix[i] = new TGeoHMatrix((*LadderCombiTrans[i])
- * (*ITSCenterCombiTrans));
- Layer->AddNode(Ladder,i+1,LadderHMatrix[i]);
- }
- return Layer;
+ + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
+ TList* laddercableassemblylist[4];
+ const Int_t kendladdercablesnumber = 4;
+ for(Int_t i=0; i<fgkladdercablesnumber; i++)
+ for(Int_t j=0; j<kendladdercablesnumber; j++){
+ laddercableassemblylist[j] =
+ GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
+ ssdendladdercablelength[j]);
+ fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
+ j<2?1:2,fladdercablematrix[i][j]);
+ }
+// fladder[0]->CheckOverlaps(0.01);
+// fladder[1]->CheckOverlaps(0.01);
}
////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
-////////////////////////////////////////////////////////////////////////////////
-// Insert the layer 5 in the mother volume.
+void AliITSv11GeometrySSD::SetLayer(){
////////////////////////////////////////////////////////////////////////////////
- if(! moth){
- cout << "Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!"<< endl;
- return;
+ // Creating Ladder of Layer 5 and Layer 6
+ /////////////////////////////////////////////////////////////
+ if(!fCreateMaterials) CreateMaterials();
+ if(!fTransformationMatrices) CreateTransformationMatrices();
+ if(!fBasicObjects) CreateBasicObjects();
+ SetLadder(); // Generating the ladder of Layer5 and Layer6
+ const Int_t kssdlayladdernumber[fgklayernumber] =
+ {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
+ /////////////////////////////////////////////////////////////
+ // Generating mother volumes for Layer5 and Layer6
+ /////////////////////////////////////////////////////////////
+ fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
+ fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
+ Int_t *ladderindex[fgklayernumber];
+ Int_t index[fgklayernumber] = {8,9};
+ for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
+ for(Int_t i=0; i<fgklayernumber; i++)
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
+ j+index[i] : j+index[i]-kssdlayladdernumber[i];
+ i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
+ fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
}
- fMotherVol = moth;
- moth->AddNode(GetLayer(5),1,0);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
}
////////////////////////////////////////////////////////////////////////////////
-void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
-////////////////////////////////////////////////////////////////////////////////
-// Insert the layer 6 in the mother volume.
+void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Insert the layer 5 in the mother volume.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
+ return;
+ };
+ if(!fSSDLayer5) SetLayer();
+ fMotherVol = moth;
+ TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
+ + fgkLay5CenterITSPosition);
+ moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
+ }
////////////////////////////////////////////////////////////////////////////////
- if(! moth){
- cout << "Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!"<< endl;
- return;
+void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Insert the layer 6 in the mother volume.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
+ return;
+ };
+ if(!fSSDLayer6) SetLayer();
+ fMotherVol = moth;
+ TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
+ + fgkLay6CenterITSPosition);
+ moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
+ /////////////////////////////////////////////////////////////
+ // Method generating the Arc structure of Ladder Support
+ /////////////////////////////////////////////////////////////
+ const Int_t kssdlayladdernumber[fgklayernumber] =
+ {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
+ Double_t mountingsupportedge[fgklayernumber];
+ Double_t mountingblockratio[fgklayernumber];
+ Double_t theta[fgklayernumber];
+ Double_t phi[fgklayernumber];
+ Double_t psi0[fgklayernumber];
+ Double_t deltapsi[fgklayernumber];
+ TVector3* mountingsupportedgevector[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
+ mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
+ *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
+ * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
+ - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
+ / kssdlayladdernumber[i])));
+ theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
+ phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
+ mountingsupportedgevector[i] = new TVector3();
+ mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
+ mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
+ -TMath::Power(mountingsupportedgevector[i]->X()
+ / fgkMountingBlockSupportRadius[i],2)));
+ psi0[i] = 0.5*TMath::Pi()-phi[i];
+ deltapsi[i] = (theta[i]+phi[i])/nedges;
+ }
+ TVector3** vertex[fgklayernumber];
+ TList* vertexlist[fgklayernumber];
+ Int_t indexedge[fgklayernumber] = {0,0};
+ for(Int_t i=0; i<fgklayernumber; i++){
+ vertex[i] = new TVector3*[nedges+1];
+ vertexlist[i] = new TList();
+ }
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<nedges+1; j++){
+ vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
+ fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
+ if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
+ vertexlist[i]->Add(vertex[i][j]);
}
- fMotherVol = moth;
- moth->AddNode(GetLayer(6),1,0);
-}
-////////////////////////////////////////////////////////////////////////////////
-TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[],
- Double_t* width, Double_t height, char* shapename){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- const Int_t TransVectNumber = 2;
- TVector3* Vertex[VertexNumber];
- TVector3* TransVector[2];
- for(Int_t i=0; i<TransVectNumber; i++)
- TransVector[i] = new TVector3(0.,width[i]);
-////////////////////////////////////////////////////////////////////////////////
- //Setting the vertices
-////////////////////////////////////////////////////////////////////////////////
- Vertex[0] = new TVector3(*vertexpos[0]);
- Vertex[1] = new TVector3(*vertexpos[1]);
- Vertex[2] = new TVector3(*Vertex[1]+*TransVector[1]);
- Vertex[3] = new TVector3(*Vertex[0]+*TransVector[0]);
- TGeoArb8* TrapezoidShape = new TGeoArb8(shapename,0.5*height);
- for(Int_t i=0; i<2*VertexNumber; i++)
- TrapezoidShape->SetVertex(i,Vertex[(i<VertexNumber ? i : i-VertexNumber)]->X(),
- Vertex[(i<VertexNumber ? i : i-VertexNumber)]->Y());
- return TrapezoidShape;
+ vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
+ }
+ Double_t** xsidevertex = new Double_t*[fgklayernumber];
+ Double_t** ysidevertex = new Double_t*[fgklayernumber];
+ Double_t** xcentervertex = new Double_t*[fgklayernumber];
+ Double_t** ycentervertex = new Double_t*[fgklayernumber];
+ Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
+ Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
+ Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
+ Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
+ ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
+ xcentervertex[i] = new Double_t[indexedge[i]+3];
+ ycentervertex[i] = new Double_t[indexedge[i]+3];
+ xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
+ ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
+ xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
+ ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
+ for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
+ xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
+ ((TVector3*)vertexlist[i]->At(j))->X();
+ ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
+ ((TVector3*)vertexlist[i]->At(j))->Y();
+ xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
+ ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
+ if(j<indexedge[i]+1){
+ xcentervertex[i][j!=indexedge[i]?j+3:0] =
+ ((TVector3*)vertexlist[i]->At(j))->X();
+ ycentervertex[i][j!=indexedge[i]?j+3:0] =
+ ((TVector3*)vertexlist[i]->At(j))->Y();
+ xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
+ ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
+ }
+ }
+ xsidevertex[i][1] = xsidevertex[i][0];
+ ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
+ xsidevertex[i][2] = xsidevertex[i][3];
+ ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
+ xcentervertex[i][1] = xcentervertex[i][0];
+ ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
+ xcentervertex[i][2] = xcentervertex[i][3];
+ ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
+ xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
+ ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
+ xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
+ ycenterlowervertex[i][0] = ysidevertex[i][0];
+ xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
+ ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
+ }
+ /////////////////////////////////////////////////////////////
+ // Building the Arc Structure of Ladder Supports
+ /////////////////////////////////////////////////////////////
+ TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
+ TGeoXtru* centermountingsupportshape[fgklayernumber];
+ TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
+ TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
+ TGeoVolume* sidemountingblocksupport[fgklayernumber];
+ TGeoVolume* centermountingblocksupport[fgklayernumber];
+ TGeoVolume* sideladdersupportpiece[fgklayernumber];
+ TGeoVolume* centerladdersupportpiece[fgklayernumber];
+ char sidemountingblockname[40];
+ char centermountingblockname[40];
+ char sideladdersupportpiecename[40];
+ char centerladdersupportpiecename[40];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
+ sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
+ sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
+ sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
+ sidemountingblocksupportshape[i] = new TGeoXtru(2);
+ sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
+ xsidevertex[i],ysidevertex[i]);
+ sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
+ sidemountingblocksupportshape[i],
+ fSSDAlCoolBlockMedium);
+ sidemountingblocksupport[i]->SetLineColor(9);
+ centermountingsupportshape[i] = new TGeoXtru(2);
+ centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
+ xcentervertex[i],ycentervertex[i]);
+ centermountingsupportshape[i]->DefineSection(0,0.);
+ centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
+ centermountingsupportshape[i],
+ fSSDAlCoolBlockMedium);
+ centermountingblocksupport[i]->SetLineColor(9);
+ sideladdersupportpieceshape[i] = new TGeoXtru(2);
+ sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
+ xsidelowervertex[i],ysidelowervertex[i]);
+ sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
+ sideladdersupportpieceshape[i],
+ fSSDSupportRingAl);
+ sideladdersupportpiece[i]->SetLineColor(fColorAl);
+ centerladdersupportpieceshape[i] = new TGeoXtru(2);
+ centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
+ xcenterlowervertex[i],ycenterlowervertex[i]);
+ centerladdersupportpieceshape[i]->DefineSection(0,0.0);
+ centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
+ centerladdersupportpieceshape[i],
+ fSSDSupportRingAl);
+ centerladdersupportpiece[i]->SetLineColor(fColorAl);
+ }
+ /////////////////////////////////////////////////////////////
+ // Building the Up Structure of Ladder Supports
+ /////////////////////////////////////////////////////////////
+ TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
+ TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
+ TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
+ //////////////////////////////////////////////////////////
+ // Setting the volume for TGeoXtru Mounting Block Piece
+ //////////////////////////////////////////////////////////
+ TGeoVolume** mountingblocksupportboxup[fgklayernumber];
+ TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
+ TGeoVolume* mountingblockpiecedown[fgklayernumber];
+ TGeoXtru* mountingblockpieceupshape[fgklayernumber];
+ TGeoVolume* mountingblockpieceup[fgklayernumber];
+ Double_t mountingblockpieceupxvertex[fgklayernumber][8];
+ Double_t mountingblockpieceupyvertex[fgklayernumber][8];
+ Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
+ Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
+ char mountingblockpiecedownname[34];
+ char mountingblockpieceupname[34];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ ///////////////////////////
+ // Mounting Block Down Vertex
+ ///////////////////////////
+ mountingblockpiecedownshape[i] = new TGeoXtru(2);
+ sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
+ mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
+ mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
+ + fgkMountingBlockSupportDownHeight;
+ mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
+ mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
+ + fgkSSDMountingBlockHeight[1]
+ - 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDModuleCoolingBlockToSensor;
+ mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
+ mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
+ mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
+ mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
+ mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
+ mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
+ mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
+ mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
+ + fgkSSDMountingBlockHeight[2]
+ - fgkSSDMountingBlockHeight[0];
+ mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
+ mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
+ mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
+ mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
+ mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
+ mountingblockpiecedownyvertex[i]);
+ mountingblockpiecedownshape[i]->DefineSection(0,0.0);
+ mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
+ mountingblockpiecedownshape[i],fSSDSupportRingAl);
+ mountingblockpiecedown[i]->SetLineColor(fColorG10);
+ ///////////////////////////
+ // Mounting Block Up Vertex
+ ///////////////////////////
+ mountingblockpieceupshape[i] = new TGeoXtru(2);
+ sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
+ mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
+ mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
+ + fgkMountingBlockSupportUpHeight[i];
+ mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
+ mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
+ + fgkSSDMountingBlockHeight[1]
+ - 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDModuleCoolingBlockToSensor;
+ mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
+ mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
+ mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
+ mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
+ mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
+ mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
+ mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
+ mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
+ + fgkSSDMountingBlockHeight[2]
+ - fgkSSDMountingBlockHeight[0];
+ mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
+ mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
+ mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
+ mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
+ mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
+ mountingblockpieceupyvertex[i]);
+ mountingblockpieceupshape[i]->DefineSection(0,0.0);
+ mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
+ mountingblockpieceupshape[i],fSSDSupportRingAl);
+ mountingblockpieceup[i]->SetLineColor(fColorG10);
+ }
+ ///////////////////////////////////////////////////////////////////
+ // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
+ ///////////////////////////////////////////////////////////////////
+ TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
+ TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
+ TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
+ TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
+ Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
+ Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
+ Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
+ Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
+ char mountingblocksupportrapezoidowname[40];
+ char mountingblocksupportrapezoidupname[40];
+ Double_t scalefactor = 3./4.;
+ for(Int_t i=0; i<fgklayernumber; i++){
+ ////////////////////////////////////////////
+ // Mounting Block Support Down Trapezoid Vertex
+ ////////////////////////////////////////////
+ mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
+ mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
+ - mountingsupportedge[i];
+ mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
+ mountingblocksupportrapezoidownxvertex[i][1] =
+ mountingblocksupportrapezoidownxvertex[i][0];
+ mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
+ + scalefactor*(mountingblockpiecedownyvertex[i][1]
+ - mountingblockpiecedownyvertex[i][0]);
+ mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
+ mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
+ mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
+ mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
+ mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
+ mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
+ mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
+ mountingblocksupportrapezoidownyvertex[i]);
+ mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
+ mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
+ mountingblocksupportrapezoidownshape[i],fSSDMountingBlockMedium);
+ mountingblocksupportrapezoidown[i]->SetLineColor(9);
+ ////////////////////////////////////////////
+ // Mounting Block Support Up Trapezoid Vertex
+ ////////////////////////////////////////////
+ mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
+ mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
+ - mountingsupportedge[i];
+ mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
+ mountingblocksupportrapezoidupxvertex[i][1] =
+ mountingblocksupportrapezoidupxvertex[i][0];
+ mountingblocksupportrapezoidupyvertex[i][1] =
+ mountingblockpieceupyvertex[i][0]
+ + scalefactor*(mountingblockpieceupyvertex[i][1]
+ - mountingblockpieceupyvertex[i][0]);
+ mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
+ mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
+ mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
+ mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
+ mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
+ mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
+ mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
+ mountingblocksupportrapezoidupyvertex[i]);
+ mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
+ -fgkMountingBlockSupportWidth[0]);
+ mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
+ mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
+ mountingblocksupportrapezoidupshape[i],fSSDMountingBlockMedium);
+ mountingblocksupportrapezoidup[i]->SetLineColor(9);
+ }
+ ///////////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
+ for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
+ Double_t boxoriginup[fgklayernumber][2][3];
+ Double_t boxorigindown[fgklayernumber][2][3];
+ char mountingblocksupportboxdownname[34];
+ char mountingblocksupportboxupname[34];
+ TGeoRotation* mountingblocksupportrot = new TGeoRotation();
+ mountingblocksupportrot->SetAngles(90.,180.,-90);
+ TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
+ globalrefladdersupportrot->SetAngles(0.,90.,0.);
+ TGeoHMatrix* laddersupportmatrix[2];
+ laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
+ laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
+ /////////////////////////////////////////////////////////////
+ // Creating Mother Volume for Containment
+ /////////////////////////////////////////////////////////////
+ Double_t *xmothervertex[fgklayernumber];
+ Double_t *ymothervertex[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ xmothervertex[i] = new Double_t[8];
+ ymothervertex[i] = new Double_t[8];
+ }
+ TGeoXtru* downmotherladdersupportshape[fgklayernumber];
+ TGeoVolume* downmotherladdersupport[fgklayernumber];
+ TGeoXtru* upmotherladdersupportshape[fgklayernumber];
+ TGeoVolume* upmotherladdersupport[fgklayernumber];
+ char upmotheladdersupportname[30];
+ char downmotheladdersupportname[30];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
+ - mountingsupportedge[i];
+ ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
+ xmothervertex[i][1] = xmothervertex[i][0];
+ ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
+ + fgkMountingBlockSupportWidth[0];
+ xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
+ ymothervertex[i][2] = ymothervertex[i][1];
+ xmothervertex[i][3] = xmothervertex[i][2];
+ ymothervertex[i][3] = -ymothervertex[i][0];
+ xmothervertex[i][4] = -xmothervertex[i][0];
+ ymothervertex[i][4] = ymothervertex[i][3];
+ xmothervertex[i][5] = xmothervertex[i][4];
+ ymothervertex[i][5] = -ymothervertex[i][1];
+ xmothervertex[i][6] = -xmothervertex[i][2];
+ ymothervertex[i][6] = ymothervertex[i][5];
+ xmothervertex[i][7] = xmothervertex[i][6];
+ ymothervertex[i][7] = ymothervertex[i][0];
+ sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
+ sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
+ downmotherladdersupportshape[i] = new TGeoXtru(2);
+ downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
+ downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
+ downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
+ + fgkMountingBlockSupportDownHeight
+ + fgkSSDMountingBlockHeight[1]
+ - 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDModuleCoolingBlockToSensor);
+ downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
+ downmotherladdersupportshape[i],fSSDAir);
+ upmotherladdersupportshape[i] = new TGeoXtru(2);
+ upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
+ upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
+ upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
+ + fgkMountingBlockSupportUpHeight[i]
+ + fgkSSDMountingBlockHeight[1]
+ - 0.5*fgkCoolingTubeSupportHeight
+ - fgkSSDModuleCoolingBlockToSensor);
+ upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
+ upmotherladdersupportshape[i],fSSDAir);
+ }
+ for(Int_t i=0; i<fgklayernumber; i++){
+ /////////////////////////
+ // Setting the box origin
+ /////////////////////////
+ boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
+ boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
+ + 0.5*fgkMountingBlockSupportDownHeight;
+ boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
+ - 0.5*fgkMountingBlockSupportWidth[0];
+
+ boxorigindown[i][1][0] = 0.0;
+ boxorigindown[i][1][1] = boxorigindown[i][0][1];
+ boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
+ - fgkMountingBlockSupportWidth[0]);
+
+ boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
+ boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
+ + 0.5*fgkMountingBlockSupportUpHeight[i];
+ boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
+ - 0.5*fgkMountingBlockSupportWidth[0];
+
+ boxoriginup[i][1][0] = 0.0;
+ boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
+ + 0.5*fgkMountingBlockSupportUpHeight[i];
+ boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
+ - fgkMountingBlockSupportWidth[0]);
+
+ /////////////////////////
+ // Setting the boxes
+ /////////////////////////
+ mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
+ + fgkSSDMountingBlockLength[0]),
+ 0.5*fgkMountingBlockSupportDownHeight,
+ 0.5*fgkMountingBlockSupportWidth[0],
+ boxorigindown[i][0]);
+ mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
+ 0.5*fgkMountingBlockSupportDownHeight,
+ 0.5*(fgkMountingBlockSupportWidth[1]
+ - fgkMountingBlockSupportWidth[0]),
+ boxorigindown[i][1]);
+
+ mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
+ + fgkSSDMountingBlockLength[0]),
+ 0.5*fgkMountingBlockSupportUpHeight[i],
+ 0.5*fgkMountingBlockSupportWidth[0],
+ boxoriginup[i][0]);
+
+ mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
+ 0.5*fgkMountingBlockSupportUpHeight[i],
+ 0.5*(fgkMountingBlockSupportWidth[1]
+ - fgkMountingBlockSupportWidth[0]),
+ boxoriginup[i][1]);
+ ///////////////////////////////////////
+ // Adding the Volumes to Mother Volume
+ ///////////////////////////////////////
+ for(Int_t j=0; j<2; j++){
+ sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
+ sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
+ mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
+ mountingblocksupportboxdownshape[i][j],
+ fSSDMountingBlockMedium);
+ mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
+ mountingblocksupportboxupshape[i][j],
+ fSSDMountingBlockMedium);
+ mountingblocksupportboxdown[i][j]->SetLineColor(9);
+ mountingblocksupportboxup[i][j]->SetLineColor(9);
+ for(Int_t k=0; k<2; k++){
+ downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
+ }
+ }
+ for(Int_t k=0; k<2; k++){
+ downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
+ }
+ }
+ TList* laddersupportlist = new TList();
+ laddersupportlist->Add(downmotherladdersupport[0]);
+ laddersupportlist->Add(upmotherladdersupport[0]);
+ laddersupportlist->Add(downmotherladdersupport[1]);
+ laddersupportlist->Add(upmotherladdersupport[1]);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<nedges+1; j++)
+ delete vertex[i][j];
+ delete mountingsupportedgevector[i];
+ delete [] vertex[i];
+ delete vertexlist[i];
+ delete [] xsidevertex[i];
+ delete [] ysidevertex[i];
+ delete [] xcentervertex[i];
+ delete [] ycentervertex[i];
+ delete [] xsidelowervertex[i];
+ delete [] ysidelowervertex[i];
+ delete [] xcenterlowervertex[i];
+ delete [] ycenterlowervertex[i];
+ }
+ delete xsidevertex;
+ delete ysidevertex;
+ delete xcentervertex;
+ delete ycentervertex;
+ delete xsidelowervertex;
+ delete ysidelowervertex;
+ delete xcenterlowervertex;
+ delete ycenterlowervertex;
+ delete globalrefladdersupportrot;
+ delete mountingblocksupportrot;
+ /////////////////////
+ return laddersupportlist;
}
-////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
+//////////////////////////////////////////
+// Method Generating Ladder Support Ring
+//////////////////////////////////////////
+ if(!fCreateMaterials) CreateMaterials();
+ if(!fTransformationMatrices) CreateTransformationMatrices();
+ if(!fBasicObjects) CreateBasicObjects();
+ fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
+ fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
+ const Int_t kssdlayladdernumber[fgklayernumber] =
+ {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
+ Double_t mountingsupportedge[fgklayernumber];
+ Double_t mountingblockratio[fgklayernumber];
+ Double_t theta[fgklayernumber];
+ Double_t phi[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
+ mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
+ *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
+ * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
+ - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
+ / kssdlayladdernumber[i])));
+ theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
+ / fgkMountingBlockSupportRadius[i]);
+ phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
+ }
+ TGeoRotation* globalrot = new TGeoRotation();
+ globalrot->SetAngles(0.,-90.,0.);
+ TGeoRotation** laddersupportrot[fgklayernumber];
+ TGeoHMatrix** laddersupportmatrix[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
+ laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ laddersupportrot[i][j] = new TGeoRotation();
+ laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
+ switch(i){
+ case 0: //Ladder of Layer5
+ laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
+ fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
+ laddersupportmatrix[i][j]);
+ break;
+ case 1: //Ladder of Layer6
+ laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
+ fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
+ laddersupportmatrix[i][j]);
+ break;
+ }
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ // Creating Lower Ladder Support
+ /////////////////////////////////////////////////////////////
+ TVector3** ringsupportvertex[fgklayernumber];
+ Double_t angle = 360./nedges;
+ for(Int_t i=0; i<fgklayernumber; i++){
+ ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
+ ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
+ * TMath::Cos(theta[i]));
+ ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
+ - mountingsupportedge[i],
+ ringsupportvertex[i][0]->Y());
+ ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
+ ringsupportvertex[i][1]->Y());
+ ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
+ for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
+ ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
+ ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
+ ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
+ ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
+ }
+ ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
+ for(Int_t j=0; j<nedges+1; j++){
+ ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
+ new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
+ (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
+ }
+ }
+ Double_t **xmothervertex = new Double_t*[fgklayernumber];
+ Double_t **ymothervertex = new Double_t*[fgklayernumber];
+ for(Int_t i=0; i<fgklayernumber; i++){
+ xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
+ ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
+ for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
+ xmothervertex[i][j] = ringsupportvertex[i][j]->X();
+ ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
+ }
+ }
+ char lowerladdersupportname[30];
+ TGeoXtru* lowerladdersupportshape[fgklayernumber];
+ TGeoVolume* lowerladdersupport[fgklayernumber];
+ TGeoRotation* lowerladdersupportrot = new TGeoRotation();
+ lowerladdersupportrot->SetAngles(90.,180.,-90);
+ for(Int_t i=0; i<fgklayernumber; i++){
+ lowerladdersupportshape[i] = new TGeoXtru(2);
+ lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
+ xmothervertex[i],ymothervertex[i]);
+ lowerladdersupportshape[i]->DefineSection(0,0.);
+ lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
+ sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
+ lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
+ lowerladdersupportshape[i],fSSDSupportRingAl);
+ lowerladdersupport[i]->SetLineColor(fColorAl);
+ (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
+ (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
+ delete ringsupportvertex[i][j];
+ delete [] ringsupportvertex[i];
+ }
+ for(Int_t i=0; i<fgklayernumber; i++){
+ delete [] xmothervertex[i];
+ delete [] ymothervertex[i];
+ }
+ delete xmothervertex;
+ delete ymothervertex;
+ delete globalrot;
+ for(Int_t i=0; i<fgklayernumber; i++){
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
+ delete laddersupportrot[i][j];
+ delete [] laddersupportrot[i];
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
+ /////////////////////////////////////////////////////////////
+ // Method generating Endcap CoverPlate
+ /////////////////////////////////////////////////////////////
+ // Holes Definition
+ ///////////////////
+ Int_t nendcapcoverplateholedges = 30;
+ const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
+ Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
+ 0.5*fgkEndCapCoverPlateThickness};
+ TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
+ nendcapcoverplateholedges,holesection);
+ TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
+ endcapcoverplatesmallholeshape,fSSDAir);
+ endcapcoverplatesmallhole->SetLineColor(6);
+ TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
+ nendcapcoverplateholedges,holesection);
+ TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
+ endcapcoverplatebigholeshape,fSSDAir);
+ endcapcoverplatebighole->SetLineColor(6);
+ //////////////////////////
+ // Screw Piece Definition
+ //////////////////////////
+ Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
+ TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
+ CosD(0.5*smallscrewangle),
+ 0.5*fgkEndCapCoverPlateThickness);
+ TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
+ endcapsmallscrewpieceshape,
+ fSSDCoolingTubePhynox);
+ endcapsmallscrewpiece->SetLineColor(fColorPhynox);
+ ///////////////////
+ // Box Definition
+ ///////////////////
+ TGeoBBox* endcapcoverplateboxshape[4];
+ TGeoVolume* endcapcoverplatebox[4];
+ Double_t boxorigin[5][3];
+ boxorigin[0][0] = 0.;
+ boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
+ boxorigin[0][2] = 0.;
+
+ boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
+ boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
+ boxorigin[1][2] = 0.;
+
+ boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + fgkEndCapCoverPlateSmallHoleSeparation[1];
+ boxorigin[2][1] = boxorigin[1][1];
+ boxorigin[2][2] = 0.;
+
+ boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
+ boxorigin[3][1] = boxorigin[1][1];
+ boxorigin[3][2] = 0.;
+
+ endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
+ 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
+ - 2.*fgkEndCapCoverPlateSmallHoleRadius),
+ 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
+
+ endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
+ -2.*fgkEndCapCoverPlateSmallHoleRadius),
+ 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
+ + fgkEndCapCoverPlateSmallHoleRadius,
+ 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
+
+ endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
+ -2.*fgkEndCapCoverPlateSmallHoleRadius),
+ 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
+ + fgkEndCapCoverPlateSmallHoleRadius,
+ 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
+
+ endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
+ -2.*fgkEndCapCoverPlateSmallHoleRadius),
+ 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
+ + fgkEndCapCoverPlateSmallHoleRadius,
+ 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
+
+ endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
+ fSSDAir);
+ endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
+ fSSDAir);
+ endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
+ fSSDAir);
+ endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
+ fSSDAir);
+ endcapcoverplatebox[0]->SetLineColor(6);
+ endcapcoverplatebox[1]->SetLineColor(6);
+ endcapcoverplatebox[2]->SetLineColor(6);
+ endcapcoverplatebox[3]->SetLineColor(6);
+ Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
+ TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
+ fgkEndCapCoverPlateSmallHoleRadius,
+ 0.5*fgkEndCapCoverPlateThickness,
+ endcapfillingboxorigin);
+ TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
+ fSSDAir);
+ endcapfillingbox->SetLineColor(6);
+ ////////////////////////////
+ // Contour Xtru Definition
+ ////////////////////////////
+ const Int_t kcontourvertexnumber = 10;
+ Double_t xcontourvertex[kcontourvertexnumber];
+ Double_t ycontourvertex[kcontourvertexnumber];
+ xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
+ xcontourvertex[1] = xcontourvertex[0];
+ xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
+ xcontourvertex[3] = xcontourvertex[2];
+ xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
+ xcontourvertex[5] = xcontourvertex[4];
+ xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
+ xcontourvertex[7] = xcontourvertex[6];
+ xcontourvertex[8] = xcontourvertex[4];
+ xcontourvertex[9] = xcontourvertex[8];
+ ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]);
+ ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
+ ycontourvertex[2] = ycontourvertex[1];
+ ycontourvertex[3] = ycontourvertex[0];
+ ycontourvertex[4] = ycontourvertex[3];
+ ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
+ ycontourvertex[6] = ycontourvertex[5];
+ ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]
+ + fgkEndCapCoverPlateSmallHoleRadius;
+ ycontourvertex[8] = ycontourvertex[7];
+ ycontourvertex[9] = ycontourvertex[0];
+ TGeoXtru* contourshape = new TGeoXtru(2);
+ contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
+ contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
+ contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
+ TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,fSSDAir);
+ contour->SetLineColor(6);
+ /////////////////////////////
+ // Hole Contour Xtru Definition
+ ////////////////////////////
+ const Int_t kholecontourvertexnumber = 10;
+ Double_t xholecontourvertex[2][kcontourvertexnumber];
+ Double_t yholecontourvertex[2][kcontourvertexnumber];
+ xholecontourvertex[0][0] = xcontourvertex[0];
+ xholecontourvertex[0][1] = xholecontourvertex[0][0];
+ xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
+ xholecontourvertex[0][3] = xholecontourvertex[0][2];
+ xholecontourvertex[0][4] = xholecontourvertex[0][0]
+ + 0.5*(fgkEndCapCoverPlateLength[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ xholecontourvertex[0][5] = xholecontourvertex[0][4];
+ xholecontourvertex[0][6] = xholecontourvertex[0][5]
+ + 2.*fgkEndCapCoverPlateBigHoleRadius;
+ xholecontourvertex[0][7] = xholecontourvertex[0][6];
+ xholecontourvertex[0][8] = xholecontourvertex[0][4];
+ xholecontourvertex[0][9] = xholecontourvertex[0][8];
+
+ yholecontourvertex[0][0] = ycontourvertex[1];
+ yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
+ yholecontourvertex[0][2] = yholecontourvertex[0][1];
+ yholecontourvertex[0][3] = yholecontourvertex[0][0];
+ yholecontourvertex[0][4] = yholecontourvertex[0][3];
+ yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ yholecontourvertex[0][6] = yholecontourvertex[0][5];
+ yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
+ yholecontourvertex[0][8] = yholecontourvertex[0][7];
+ yholecontourvertex[0][9] = yholecontourvertex[0][0];
+
+ xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
+ xholecontourvertex[1][1] = xholecontourvertex[1][0];
+ xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
+ xholecontourvertex[1][3] = xholecontourvertex[1][2];
+ xholecontourvertex[1][4] = xholecontourvertex[1][0]
+ + 0.5*(fgkEndCapCoverPlateLength[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ xholecontourvertex[1][5] = xholecontourvertex[1][4];
+ xholecontourvertex[1][6] = xholecontourvertex[1][5]
+ + 2.*fgkEndCapCoverPlateBigHoleRadius;
+ xholecontourvertex[1][7] = xholecontourvertex[1][6];
+ xholecontourvertex[1][8] = xholecontourvertex[1][4];
+ xholecontourvertex[1][9] = xholecontourvertex[1][8];
+
+ yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]);
+ yholecontourvertex[1][1] = ycontourvertex[0];
+ yholecontourvertex[1][2] = yholecontourvertex[1][1];
+ yholecontourvertex[1][3] = yholecontourvertex[1][0];
+ yholecontourvertex[1][4] = yholecontourvertex[1][3];
+ yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ yholecontourvertex[1][6] = yholecontourvertex[1][5];
+ yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
+ yholecontourvertex[1][8] = yholecontourvertex[1][7];
+ yholecontourvertex[1][9] = yholecontourvertex[1][0];
+
+ TGeoXtru* holecontourshape[2];
+ holecontourshape[0] = new TGeoXtru(2);
+ holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
+ yholecontourvertex[0]);
+ holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
+ holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
+
+ holecontourshape[1] = new TGeoXtru(2);
+ holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
+ yholecontourvertex[1]);
+ holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
+ holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
+
+ TGeoVolume* holecontour[2];
+ holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],fSSDAir);
+ holecontour[0]->SetLineColor(6);
+ holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],fSSDAir);
+ holecontour[1]->SetLineColor(6);
+ TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
+ + fgkEndCapCoverPlateLength[2],0.,0.);
+ TGeoTranslation* bigholetrans[3];
+ bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
+ yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
+ bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
+ + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
+ - fgkEndCapCoverPlateBigHoleRadius,0.0);
+ bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
+ yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
+ /////////////////////////////////
+ // Mother Volume Xtru Definition
+ /////////////////////////////////
+ const Int_t kmothervertexnumber = 12;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ xmothervertex[0] = xcontourvertex[0];
+ xmothervertex[1] = xmothervertex[0];
+ xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
+ xmothervertex[3] = xmothervertex[2];
+ xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
+ xmothervertex[5] = xmothervertex[4];
+ xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
+ xmothervertex[7] = xmothervertex[6];
+ xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
+ + fgkEndCapCoverPlateLength[2];
+ xmothervertex[9] = xmothervertex[8];
+ xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
+ xmothervertex[11] = xmothervertex[10];
+
+ ymothervertex[0] = ycontourvertex[0];
+ ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
+ ymothervertex[2] = ymothervertex[1];
+ ymothervertex[3] = ycontourvertex[1];
+ ymothervertex[4] = ymothervertex[3];
+ ymothervertex[5] = ymothervertex[1];
+ ymothervertex[6] = ymothervertex[5];
+ ymothervertex[7] = ymothervertex[0];
+ ymothervertex[8] = ymothervertex[7];
+ ymothervertex[9] = ymothervertex[8]
+ - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
+ ymothervertex[10] = ymothervertex[9];
+ ymothervertex[11] = ymothervertex[8];
+ TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
+ mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
+ mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
+ mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
+ TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
+ ////////////////////////////////////////
+ // Adding Nodes
+ ////////////////////////////////////////
+// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
+ TGeoTranslation*** endcapcoverplatesmallholetrans;
+ endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
+ Double_t transx[4] = {0,
+ fgkEndCapCoverPlateSmallHoleSeparation[0],
+ fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + fgkEndCapCoverPlateSmallHoleSeparation[1],
+ 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + fgkEndCapCoverPlateSmallHoleSeparation[1]};
+ Int_t index = 0;
+ for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
+ endcapcoverplatesmallholetrans[i] =
+ new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
+ for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
+ index = kendcapcoverplatesmallholenumber[1]*i+j+1;
+ endcapcoverplatesmallholetrans[i][j] =
+ new TGeoTranslation(transx[i],
+ j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
+ if(index!=10){
+ mothercoverplate->AddNode(endcapcoverplatesmallhole,
+ index,endcapcoverplatesmallholetrans[i][j]);
+ mothercoverplate->AddNode(endcapsmallscrewpiece,
+ index,endcapcoverplatesmallholetrans[i][j]);
+ }
+ if(j<kendcapcoverplatesmallholenumber[1]-1)
+ mothercoverplate->AddNode(endcapcoverplatebox[0],
+ index,endcapcoverplatesmallholetrans[i][j]);
+ }
+ }
+ mothercoverplate->AddNode(endcapcoverplatebox[1],1);
+ mothercoverplate->AddNode(endcapcoverplatebox[2],1);
+ mothercoverplate->AddNode(endcapcoverplatebox[3],1);
+ mothercoverplate->AddNode(endcapfillingbox,1);
+ mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
+ mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
+ mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
+ mothercoverplate->AddNode(holecontour[0],1);
+ mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
+ mothercoverplate->AddNode(holecontour[1],1);
+ mothercoverplate->AddNode(contour,1);
+ /////////////////////////////////
+ return mothercoverplate;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
+ /////////////////////////////////////////////////////////////
+ // Getting EndCap Cooling Tube
+ /////////////////////////////////////////////////////////////
+ TGeoTorus* endcapcoolingtubetorushape[5];
+ TGeoVolume* endcapcoolingtubetorus[5];
+ TGeoTube* endcapcoolingtubeshape[4];
+ TGeoVolume* endcapcoolingtube[4];
+ char endcapcoolingtubetorusname[30];
+ char endcapcoolingtubename[30];
+ TGeoTorus* endcapcoolingwatertubetorushape[5];
+ TGeoVolume* endcapcoolingwatertubetorus[5];
+ TGeoTube* endcapcoolingwatertubeshape[4];
+ TGeoVolume* endcapcoolingwatertube[4];
+ char endcapcoolingwatertubetorusname[30];
+ char endcapcoolingwatertubename[30];
+ for(Int_t i=0; i<5; i++){
+ sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
+ sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
+ sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
+ sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
+ if(i==3){
+ endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
+ fgkEndCapCoolingTubeRadiusMin,
+ fgkEndCapCoolingTubeRadiusMax,
+ 90.0,fgkEndCapCoolingTubeAngle[3]);
+ endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
+ 0.,fgkEndCapCoolingTubeRadiusMin,
+ 90.0,fgkEndCapCoolingTubeAngle[3]);
+ }
+ else{
+ endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
+ :fgkEndCapCoolingTubeAxialRadius[1],
+ fgkEndCapCoolingTubeRadiusMin,
+ fgkEndCapCoolingTubeRadiusMax,
+ 0.,fgkEndCapCoolingTubeAngle[i]);
+ endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
+ :fgkEndCapCoolingTubeAxialRadius[1],
+ 0.,fgkEndCapCoolingTubeRadiusMin,
+ 0.,fgkEndCapCoolingTubeAngle[i]);
+ }
+ endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
+ endcapcoolingtubetorushape[i],
+ fSSDCoolingTubePhynox);
+ endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
+ endcapcoolingwatertubetorushape[i],
+ fSSDCoolingTubeWater);
+ endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
+ endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
+ if(i<4){
+ endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
+ fgkEndCapCoolingTubeRadiusMax,
+ 0.5*fgkEndCapCoolingTubeLength[i]);
+ endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
+ 0.5*fgkEndCapCoolingTubeLength[i]);
+ endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
+ endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
+ endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
+ endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
+ endcapcoolingtube[i]->SetLineColor(fColorPhynox);
+ endcapcoolingwatertube[i]->SetLineColor(fColorWater);
+ }
+ }
+ TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
+ /////////////////////////////////////////
+ // Transformation for Volume Positioning
+ /////////////////////////////////////////
+ TGeoCombiTrans* coolingtubecombitrans[6];
+ TGeoRotation* coolingtuberot[8];
+ TGeoTranslation* coolingtubetrans[6];
+ TGeoHMatrix* coolingtubematrix[4];
+ TGeoCombiTrans* torustubecombitrans[4];
+ TGeoRotation* torustuberot[7];
+ TGeoTranslation* torustubetrans[4];
+ TGeoHMatrix* torustubematrix[5];
+ TGeoCombiTrans* coolingwatertubecombitrans[6];
+ TGeoRotation* coolingwatertuberot[8];
+ TGeoTranslation* coolingwatertubetrans[6];
+ TGeoHMatrix* coolingwatertubematrix[4];
+ TGeoCombiTrans* toruswatertubecombitrans[4];
+ TGeoRotation* toruswatertuberot[7];
+ TGeoTranslation* toruswatertubetrans[4];
+ TGeoHMatrix* toruswatertubematrix[5];
+ for(Int_t i=0; i<8; i++){
+ if(i<6){
+ coolingtubetrans[i] = new TGeoTranslation();
+ coolingwatertubetrans[i] = new TGeoTranslation();
+ }
+ if(i<8){
+ coolingtuberot[i] = new TGeoRotation();
+ coolingwatertuberot[i] = new TGeoRotation();
+ }
+ if(i<4){
+ torustubetrans[i] = new TGeoTranslation();
+ toruswatertubetrans[i] = new TGeoTranslation();
+ }
+ if(i<7){
+ torustuberot[i] = new TGeoRotation();
+ toruswatertuberot[i] = new TGeoRotation();
+ }
+ }
+ /////////////////////////////////////////
+ // Transformation for Inox Volume Positioning
+ /////////////////////////////////////////
+ coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
+ -endcapcoolingtubeshape[0]->GetDz(),0.);
+ coolingtuberot[0]->SetAngles(0.,90.,0.);
+ coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
+ *coolingtuberot[0]);
+
+ coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
+ coolingtuberot[1]->SetAngles(0.,90.,0.);
+ coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
+ *coolingtuberot[1]);
+
+ coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
+ *CosD(fgkEndCapCoolingTubeAngle[0]),
+ fgkEndCapCoolingTubeAxialRadius[0]
+ *SinD(fgkEndCapCoolingTubeAngle[0]),
+ 0.);
+ coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
+ coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
+ *coolingtuberot[2]);
+
+ coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
+ * (*coolingtubecombitrans[1]));
+
+ torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
+ endcapcoolingtubeshape[1]->GetDz());
+ torustuberot[0]->SetAngles(0.,90.,0.);
+ torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
+
+ torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
+
+ coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
+ -endcapcoolingtubeshape[2]->GetDz(),0.);
+ coolingtuberot[3]->SetAngles(0.,90.,0.);
+ coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
+ *coolingtuberot[3]);
+ coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
+ coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
+ coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
+
+ torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
+ endcapcoolingtubeshape[2]->GetDz());
+ torustuberot[1]->SetAngles(0.,90.,0.);
+ torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
+ torustuberot[2]->SetAngles(180.,0.,0.);
+ torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
+ torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
+
+ torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
+ -fgkEndCapCoolingTubeAxialRadius[0]);
+ torustuberot[3]->SetAngles(0.,90.,0.);
+ torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
+ torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
+ torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
+ torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
+
+ coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
+ fgkEndCapCoolingTubeAxialRadius[0],0.);
+ coolingtuberot[5]->SetAngles(90.,90.,-90.);
+ coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
+ *coolingtuberot[5]);
+ coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
+ coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
+ coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
+
+ torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
+ endcapcoolingtubeshape[0]->GetDz());
+ torustuberot[5]->SetAngles(0.,90.,0.);
+ torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
+ torustuberot[6]->SetAngles(-90.,0.,0.);
+ torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
+ torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
+
+ coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
+ endcapcoolingtubeshape[3]->GetDz(),0.);
+ coolingtuberot[6]->SetAngles(0.,90.,0.);
+ coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
+ *coolingtuberot[6]);
+ coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
+ coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
+ coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
+ /////////////////////////////////////////
+ // Transformation for Water Volume Positioning
+ /////////////////////////////////////////
+ coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
+ -endcapcoolingwatertubeshape[0]->GetDz(),0.);
+ coolingwatertuberot[0]->SetAngles(0.,90.,0.);
+ coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
+ *coolingwatertuberot[0]);
+
+ coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
+ coolingwatertuberot[1]->SetAngles(0.,90.,0.);
+ coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
+ *coolingwatertuberot[1]);
+
+ coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
+ *CosD(fgkEndCapCoolingTubeAngle[0]),
+ fgkEndCapCoolingTubeAxialRadius[0]
+ *SinD(fgkEndCapCoolingTubeAngle[0]),
+ 0.);
+ coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
+ coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
+ *coolingwatertuberot[2]);
+
+ coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
+ * (*coolingwatertubecombitrans[1]));
+
+ toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
+ endcapcoolingwatertubeshape[1]->GetDz());
+ toruswatertuberot[0]->SetAngles(0.,90.,0.);
+ toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
+ *toruswatertuberot[0]);
+
+ toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
+ * (*toruswatertubecombitrans[0]));
+
+ coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
+ -endcapcoolingwatertubeshape[2]->GetDz(),0.);
+ coolingwatertuberot[3]->SetAngles(0.,90.,0.);
+ coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
+ *coolingwatertuberot[3]);
+ coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
+ coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
+ * (*coolingwatertubecombitrans[3]));
+ coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
+
+ toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
+ endcapcoolingwatertubeshape[2]->GetDz());
+ toruswatertuberot[1]->SetAngles(0.,90.,0.);
+ toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
+ *toruswatertuberot[1]);
+ toruswatertuberot[2]->SetAngles(180.,0.,0.);
+ toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
+ * (*toruswatertubecombitrans[1]));
+ toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
+
+ toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
+ -fgkEndCapCoolingTubeAxialRadius[0]);
+ toruswatertuberot[3]->SetAngles(0.,90.,0.);
+ toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
+ *toruswatertuberot[3]);
+ toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
+ toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
+ * (*toruswatertubecombitrans[2]));
+ toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
+
+ coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
+ fgkEndCapCoolingTubeAxialRadius[0],0.);
+ coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
+ coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
+ *coolingwatertuberot[5]);
+ coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
+ coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
+ * (*coolingwatertubecombitrans[4]));
+ coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
+
+ toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
+ endcapcoolingwatertubeshape[0]->GetDz());
+ toruswatertuberot[5]->SetAngles(0.,90.,0.);
+ toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
+ *toruswatertuberot[5]);
+ toruswatertuberot[6]->SetAngles(-90.,0.,0.);
+ toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
+ * (*toruswatertubecombitrans[3]));
+ toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
+
+ coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
+ endcapcoolingwatertubeshape[3]->GetDz(),0.);
+ coolingwatertuberot[6]->SetAngles(0.,90.,0.);
+ coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
+ *coolingwatertuberot[6]);
+ coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
+ coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
+ * (*coolingwatertubecombitrans[5]));
+ coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
+ /////////////////////////////////////////
+ // Positioning Volumes
+ /////////////////////////////////////////
+ endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
+
+ endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
+ endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<8; i++){
+ if(i<6){
+ delete coolingtubetrans[i];
+ delete coolingwatertubetrans[i];
+ if(i!=0){
+ delete coolingtubecombitrans[i];
+ delete coolingwatertubecombitrans[i];
+ }
+ }
+ if(i<8){
+ delete coolingtuberot[i];
+ delete coolingwatertuberot[i];
+ }
+ if(i<4){
+ delete torustubetrans[i];
+ delete toruswatertubetrans[i];
+ delete torustubecombitrans[i];
+ delete toruswatertubecombitrans[i];
+ }
+ if(i<7){
+ delete torustuberot[i];
+ delete toruswatertuberot[i];
+ }
+ }
+ /////////////////////////////////////////////////////////////
+ return endcapcoolingtubemother;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
+ /////////////////////////////////////////////////////////////
+ // Getting EndCap Cover Side
+ /////////////////////////////////////////////////////////////
+ const Int_t kendcapcoverholenumber[2] = {7,5};
+ const Int_t kvertexnumber = 15;
+ Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
+ xvertex[0] = 0.0;
+ xvertex[1] = xvertex[0];
+ xvertex[2] = fgkEndCapSideCoverLength[0];
+ xvertex[3] = fgkEndCapSideCoverLength[1];
+ xvertex[4] = xvertex[3];
+ xvertex[5] = fgkEndCapSideCoverLength[2];
+ xvertex[6] = xvertex[5];
+ xvertex[7] = xvertex[2];
+ xvertex[8] = xvertex[7];
+ xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
+ xvertex[10] = xvertex[9];
+ xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
+ * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
+ * fgkEndCapSideCoverLength[4];
+ xvertex[12] = xvertex[11];
+ xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
+ * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
+ * fgkEndCapSideCoverLength[4];
+ xvertex[14] = xvertex[13];
+ yvertex[0] = 0.0;
+ yvertex[1] = fgkEndCapSideCoverWidth[0];
+ yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
+ yvertex[3] = yvertex[2];
+ yvertex[4] = fgkEndCapSideCoverWidth[1];
+ yvertex[5] = yvertex[4];
+ yvertex[6] = yvertex[0];
+ yvertex[7] = yvertex[6];
+ yvertex[8] = fgkEndCapSideCoverWidth[6];
+ yvertex[9] = yvertex[8];
+ yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
+ yvertex[11] = yvertex[10];
+ yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
+ yvertex[13] = yvertex[12];
+ yvertex[14] = yvertex[6];
+ TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
+ endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
+ endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
+ endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
+ TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
+ endcapsidecovershape,fSSDCoolingTubePhynox);
+ endcapsidecover->SetLineColor(fColorPhynox);
+ ////////////////////////////////////////////
+ // Defininition of Mother Volume
+ ////////////////////////////////////////////
+ const Int_t kmothervertexnumber = 7;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ for(Int_t i=0; i<kmothervertexnumber; i++){
+ xmothervertex[i] = xvertex[i];
+ ymothervertex[i] = yvertex[i];
+ }
+ TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
+ endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
+ endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
+ endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
+ TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
+ endcapsidecovermothershape,fSSDAir);
+ ////////////////////////////////////////////
+ endcapsidecovermother->AddNode(endcapsidecover,1);
+ TGeoBBox* endcapsidecoverboxshape[4];
+ endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
+ + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
+ 0.5*fgkEndCapSideCoverLength[4],
+ 0.5*fgkEndCapSideCoverThickness);
+ endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
+ + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
+ 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
+ - fgkEndCapSideCoverLength[4]),
+ 0.5*fgkEndCapSideCoverThickness);
+ endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
+ 0.5*fgkEndCapSideCoverLength[4],
+ 0.5*fgkEndCapSideCoverThickness);
+ endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
+ 0.5*fgkEndCapSideCoverWidth[5],
+ 0.5*fgkEndCapSideCoverThickness);
+ TGeoVolume* endcapsidecoverbox[4];
+ endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
+ endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
+ endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
+ endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
+ for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
+// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
+ TGeoTranslation** endcapsidecoverboxtrans;
+ endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
+ endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
+ + fgkEndCapSideCoverLength[0],
+ endcapsidecoverboxshape[0]->GetDY()
+ + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
+ endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
+ + xvertex[11],
+ endcapsidecoverboxshape[1]->GetDY()
+ + yvertex[12],0.);
+ endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
+ + xvertex[11],
+ endcapsidecoverboxshape[2]->GetDY()
+ + yvertex[12]
+ + 2.*endcapsidecoverboxshape[1]->GetDY()
+ + fgkEndCapSideCoverWidth[5],0.);
+ endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
+ endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
+ endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
+ for(Int_t i=0; i<2; i++)
+ for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
+ endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
+ new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
+ +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
+ endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
+ +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
+ endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
+ endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
+ }
+ for(Int_t i=0; i<2; i++)
+ for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
+ endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
+ new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
+ +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
+ endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
+ +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
+ +fgkEndCapSideCoverLength[4]),0.0);
+ endcapsidecovermother->AddNode(endcapsidecoverbox[3],
+ 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
+ endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
+ +i*(kendcapcoverholenumber[1]-1)+j]);
+ }
+ return endcapsidecovermother;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
+ ////////////////////////////////////////////////////////////////////////////////
+ // Method returning Interface Card A, Interface Card B, Supply Card
+ ////////////////////////////////////////////////////////////////////////////////
+ /////////////////////
+ // Supply Card
+ /////////////////////
+ // Electronic Board Back Al Plane
+ const Int_t kelectboardbackvertexnumber = 8;
+ Double_t xelectboardback[kelectboardbackvertexnumber];
+ Double_t yelectboardback[kelectboardbackvertexnumber];
+ xelectboardback[0] = 0.0;
+ xelectboardback[1] = xelectboardback[0];
+ xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
+ xelectboardback[3] = xelectboardback[2];
+ xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
+ xelectboardback[5] = xelectboardback[4];
+ xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
+ xelectboardback[7] = xelectboardback[6];
+
+ yelectboardback[0] = 0.0;
+ yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
+ yelectboardback[2] = yelectboardback[1];
+ yelectboardback[3] = yelectboardback[0];
+ yelectboardback[4] = yelectboardback[3];
+ yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
+ yelectboardback[6] = yelectboardback[5];
+ yelectboardback[7] = yelectboardback[4];
+ TGeoXtru* electboardbackshape = new TGeoXtru(2);
+ electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
+ xelectboardback,yelectboardback);
+ electboardbackshape->DefineSection(0,0.0);
+ electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
+ TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
+ electboardbackshape,fSSDSupportRingAl);
+ electboardback->SetLineColor(fColorAl);
+ // Electronic Board Kapton Layer
+ const Int_t kelectlayervertexnumber = 8;
+ Double_t xelectlayer[kelectlayervertexnumber];
+ Double_t yelectlayer[kelectlayervertexnumber];
+ xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
+ xelectlayer[1] = xelectlayer[0];
+ xelectlayer[2] = fgkEndCapCardElectBoardLength;
+ xelectlayer[3] = xelectlayer[2];
+ for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
+
+ yelectlayer[0] = 0.0;
+ yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
+ yelectlayer[2] = yelectlayer[1];
+ yelectlayer[3] = yelectlayer[0];
+ yelectlayer[4] = yelectlayer[3];
+ yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
+ yelectlayer[6] = yelectlayer[5];
+ yelectlayer[7] = yelectlayer[4];
+ TGeoXtru* electlayershape = new TGeoXtru(2);
+ electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
+ electlayershape->DefineSection(0,0.0);
+ electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
+ TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
+ electlayershape,fSSDKaptonFlexMedium);
+ electlayer->SetLineColor(fColorKapton);
+ // JMD Connector Female
+ const Int_t kjmdconnectorvertexnumber = 6;
+ Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
+ Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
+ xjmdconnectorvertex[0] = 0.0;
+ xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
+ xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
+ xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
+ xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
+ xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
+
+ yjmdconnectorvertex[0] = 0.0;
+ yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
+ yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
+ yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
+ yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
+ yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
+ TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
+ jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
+ yjmdconnectorvertex);
+ jmdconnectorshape->DefineSection(0,0.0);
+ jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
+ TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
+ jmdconnectorshape,fSSDMountingBlockMedium);
+ jmdconnector->SetLineColor(fColorG10);
+ // Top Cable Connector
+ const Int_t kcableconnectorvertexnumber = 8;
+ Double_t xconnectorvertex[kcableconnectorvertexnumber];
+ Double_t yconnectorvertex[kcableconnectorvertexnumber];
+ xconnectorvertex[0] = 0.0;
+ xconnectorvertex[1] = xconnectorvertex[0];
+ xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
+ xconnectorvertex[3] = xconnectorvertex[2];
+ xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
+ - fgkEndCapCardCableConnectorLength[2];
+ xconnectorvertex[5] = xconnectorvertex[4];
+ xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
+ xconnectorvertex[7] = xconnectorvertex[6];
+
+ yconnectorvertex[0] = 0.0;
+ yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
+ yconnectorvertex[2] = yconnectorvertex[1];
+ yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
+ yconnectorvertex[4] = yconnectorvertex[3];
+ yconnectorvertex[5] = yconnectorvertex[1];
+ yconnectorvertex[6] = yconnectorvertex[5];
+ yconnectorvertex[7] = yconnectorvertex[0];
+ TGeoXtru* cableconnectorshape = new TGeoXtru(2);
+ cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
+ yconnectorvertex);
+ cableconnectorshape->DefineSection(0,0.0);
+ cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
+ TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
+ cableconnectorshape,fSSDMountingBlockMedium);
+ cableconnector->SetLineColor(fColorG10);
+ // Strip Connection
+ TGeoBBox* endcapstripconnectionshape =
+ new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
+ 0.5*fgkEndCapStripConnectionThickness,
+ 0.5*fgkEndCapStripConnectionWidth);
+ TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
+ endcapstripconnectionshape,
+ fSSDSupportRingAl);
+ endcapstripconnection->SetLineColor(fColorAl);
+ // Interface Card B
+ const Int_t kcardBvertexnumber = 12;
+ Double_t xcardBvertexnumber[kcardBvertexnumber];
+ Double_t ycardBvertexnumber[kcardBvertexnumber];
+
+ xcardBvertexnumber[0] = 0.0;
+ xcardBvertexnumber[1] = xcardBvertexnumber[0];
+ xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
+ xcardBvertexnumber[3] = xcardBvertexnumber[2];
+ xcardBvertexnumber[4] = xcardBvertexnumber[1];
+ xcardBvertexnumber[5] = xcardBvertexnumber[4];
+ xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
+ xcardBvertexnumber[7] = xcardBvertexnumber[6];
+ xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
+ xcardBvertexnumber[9] = xcardBvertexnumber[8];
+ xcardBvertexnumber[10] = xcardBvertexnumber[7];
+ xcardBvertexnumber[11] = xcardBvertexnumber[10];
+
+ ycardBvertexnumber[0] = 0.0;
+ ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
+ ycardBvertexnumber[2] = ycardBvertexnumber[1];
+ ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
+ ycardBvertexnumber[4] = ycardBvertexnumber[3];
+ ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
+ ycardBvertexnumber[6] = ycardBvertexnumber[5];
+ ycardBvertexnumber[7] = ycardBvertexnumber[4];
+ ycardBvertexnumber[8] = ycardBvertexnumber[7];
+ ycardBvertexnumber[9] = ycardBvertexnumber[1];
+ ycardBvertexnumber[10] = ycardBvertexnumber[9];
+ ycardBvertexnumber[11] = ycardBvertexnumber[0];
+
+ TGeoXtru* interfacecardBshape = new TGeoXtru(2);
+ interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
+ interfacecardBshape->DefineSection(0,0.);
+ interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
+ TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
+ fSSDMountingBlockMedium);
+ interfacecardB->SetLineColor(46);
+ // Interface Card B Electronic Board
+ const Int_t kelectboardcardBvertexnumber = 14;
+ Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
+ Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
+
+ xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
+ xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
+ xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
+ xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
+ xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
+ xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
+ xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
+ xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
+ xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
+ xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
+ xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
+ xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
+ xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
+ xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
+
+ yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
+ yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
+ yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
+ yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
+ yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
+ yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
+ yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
+ yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
+ yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
+ yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
+ yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
+ yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
+ yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
+ yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
+
+ TGeoXtru* electboardcardBshape = new TGeoXtru(2);
+ electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
+ xelectboardcardBvertex,yelectboardcardBvertex);
+ electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
+ electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
+ + fgkEndCapInterfaceElectBoardCardBThickness);
+ TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
+ fSSDSupportRingAl);
+ electboardcardB->SetLineColor(fColorAl);
+ // Generating Stiffener 2
+ TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
+ 0.5*fgkEndCapStiffenerThickness,
+ 0.5*fgkEndCapStiffenerLength);
+ TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
+ endcapstiffener->SetLineColor(fColorAl);
+ // Generating Mother Interface Card B Container
+ const Int_t kinterfacecardBmothervertexnumber = 10;
+ Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
+ Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
+
+ xinterfacecardBmothervertex[0] = 0.0;
+ xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
+ xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
+ + fgkEndCapInterfaceCardBThickness;
+ xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
+ xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
+ + fgkEndCapInterfaceElectBoardCardBThickness;
+ xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
+ xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
+ xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
+ xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
+ + fgkEndCapCardJMDConnectorLength[0];
+ xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
+
+ yinterfacecardBmothervertex[0] = 0.0;
+ yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
+ + fgkEndCapInterfaceCardBWidth[1]
+ + fgkEndCapInterfaceCardBWidth[2];
+ yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
+ yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
+ yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
+ yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
+ yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
+ yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
+ + fgkEndCapCardJMDConnectorWidth[0]
+ + fgkEndCapCardJMDConnectorWidth[1];
+ yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
+ yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
+ TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
+ interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
+ xinterfacecardBmothervertex,
+ yinterfacecardBmothervertex);
+ interfacecardBmothershape->DefineSection(0,-1.e-15);
+ interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
+ TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
+ interfacecardBmothershape,fSSDAir);
+ electboardcardB->SetLineColor(fColorAl);
+ // Positioning Volumes Mother Interface Card B Container
+ TGeoRotation* interfacecardBrot = new TGeoRotation();
+ TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
+ interfacecardBrot->SetAngles(90.,-90.,-90.);
+ interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
+ TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
+ TGeoRotation* electboardcardBrot = new TGeoRotation();
+ TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
+ electboardcardBrot->SetAngles(90.,90.,-90.);
+ electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
+ TGeoCombiTrans* electboardcardBcombitrans =
+ new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
+ interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
+ interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
+ TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
+ jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
+ TGeoTranslation* jmdconnectorcardBtrans[3];
+ TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
+ for(Int_t i=0; i<3; i++){
+ jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
+ + fgkEndCapCardJMDConnectorLength[0],
+ fgkEndCapCardElectBoardLayerWidth[1],
+ 0.5*fgkEndCapCardJMDConnectorThickness
+ + 0.5*(fgkEndCapInterfaceCardBLength[1]
+ - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
+ + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
+ jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
+ *jmdconnectorcardBrot);
+ interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
+ }
+ // Mother Supply Card Container
+ TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
+ // Interface Card Container
+ TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
+ // Placing Volumes in Mother Supply Card Container
+ // JMD Connector Positioning
+ TGeoTranslation* jmdconnectortrans[2];
+ for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
+ jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
+ fgkEndCapCardElectBoardBackLength[0]
+ - fgkEndCapCardJMDConnectorThickness
+ - fgkEndCapCardJMDConnectorToLayer);
+ TGeoRotation* jmdconnectorot = new TGeoRotation();
+ jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
+ + 2.*fgkEndCapCardJMDConnectorLength[0]
+ + 2.*fgkEndCapCardElectBoardLayerThickness,
+ fgkEndCapCardElectBoardLayerWidth[1],
+ fgkEndCapCardJMDConnectorThickness
+ + fgkEndCapCardJMDConnectorToLayer);
+ jmdconnectorot->SetAngles(90.,180.,-90);
+ TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
+ * jmdconnectorot);
+ mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
+ mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
+ // Top Cable Connector Placing
+ TGeoRotation* cableconnectorot[2];
+ for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
+ TGeoTranslation* cableconnectortrans[3];
+ for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
+ cableconnectorot[0]->SetAngles(90.,0.,0.);
+ cableconnectorot[1]->SetAngles(0.,-90.,0.);
+ cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
+ TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
+ *cableconnectorot[0]);
+ TGeoHMatrix* cableconnectormatrix[2];
+ for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
+ new TGeoHMatrix((*cableconnectorot[1])
+ *(*cableconnectorcombitrans));
+ cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
+ - fgkEndCapCardCableConnectorThickness,
+ fgkEndCapCardCableConnectorLength[0]
+ + fgkEndCapCardCableConnectorToLayer);
+ cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
+ - 2.*fgkEndCapCardCableConnectorThickness
+ - fgkEndCapCardCableConnectorDistance,
+ fgkEndCapCardCableConnectorLength[0]
+ + fgkEndCapCardCableConnectorToLayer);
+ for(Int_t i=0; i<2; i++){
+ cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
+ mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
+ }
+ TGeoRotation* electboardbackrot = new TGeoRotation();
+ TGeoTranslation* electboardbacktrans = new TGeoTranslation();
+ electboardbackrot->SetAngles(90.,-90.,-90.);
+ electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
+ + fgkEndCapCardJMDConnectorLength[0]
+ + fgkEndCapCardElectBoardLayerThickness,0.,0.);
+ TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
+ *electboardbackrot);
+ mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
+ // Electronic Board Kapton Layer Positioning
+ TGeoRotation* electlayerrot = new TGeoRotation();
+ TGeoTranslation* electlayertrans[2];
+ TGeoCombiTrans* electlayercombitrans[2];
+ for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
+ electlayerrot->SetAngles(90.,-90.,-90.);
+ electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
+ + fgkEndCapCardElectBoardLayerThickness,0.,0.);
+ electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
+ + 2.*fgkEndCapCardElectBoardLayerThickness
+ + fgkEndCapCardElectBoardBackThickness,0.,0.);
+ for(Int_t i=0; i<2; i++){
+ electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
+ mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
+ }
+ // Placing Volumes in Mother Interface Card Container
+ motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
+ motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
+ for(Int_t i=0; i<2; i++){
+ motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
+ }
+ /////////////////////////////////////////////////////////////
+ // Generation of Card Interface Container
+ /////////////////////////////////////////////////////////////
+ Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
+ - fgkEndCapCardJMDConnectorLength[0]
+ - fgkEndCapInterfaceCardBThickness
+ - 9.*fgkEndCapStripConnectionThickness
+ - 8.*fgkEndCapCardElectBoardBackThickness;
+ const Int_t kcardinterfacecontainervertexnumber = 14;
+ Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
+ Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
+ xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
+ - 7.0*fgkEndCapStripConnectionThickness;
+ xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
+ xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
+ + fgkEndCapStripConnectionThickness
+ - fgkEndCapCardElectBoardLayerThickness
+ - fgkEndCapCardCableConnectorWidth[0];
+ xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
+ xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
+ xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
+ xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
+ + 2.0*fgkEndCapStripConnectionThickness;
+ xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
+ xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
+ + fgkEndCapInterfaceCardBThickness;
+ xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
+ xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
+ + fgkEndCapInterfaceElectBoardCardBThickness;
+ xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
+ xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
+ - fgkEndCapInterfaceElectBoardCardBThickness
+ + fgkEndCapCardJMDConnectorLength[0]
+ + stiffenertransx+fgkEndCapStiffenerWidth;
+ xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
+
+ ycardinterfacecontainervertex[0] = 0.;
+ ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
+ + fgkEndCapCardJMDConnectorWidth[0]
+ + fgkEndCapCardJMDConnectorWidth[1];
+ ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
+ ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
+ - fgkEndCapStripConnectionWidth;
+ ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
+ ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
+ ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
+ ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
+ + fgkEndCapInterfaceCardBWidth[1]
+ + fgkEndCapInterfaceCardBWidth[2];
+ ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
+ ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
+ ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
+ ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
+ ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
+ ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
+
+ TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
+ interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
+ xcardinterfacecontainervertex,
+ ycardinterfacecontainervertex);
+ interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
+ - fgkEndCapCardElectBoardBackLength[0]));
+ interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
+ + fgkEndCapCardElectBoardBackLength[0]));
+ TGeoVolume** cardinterfacecontainer;
+ cardinterfacecontainer = new TGeoVolume*[4];
+ cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
+ interfacecardmothershape,fSSDAir);
+ cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
+ interfacecardmothershape,fSSDAir);
+ cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
+ interfacecardmothershape,fSSDAir);
+ cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
+ interfacecardmothershape,fSSDAir);
+ /////////////////////////////////
+ // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
+ // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
+ // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
+ // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
+ /////////////////////////////////
+ TGeoRotation* endcapstripconnectionrot[2];
+ for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
+ endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
+ endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
+ TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
+ * (*endcapstripconnectionrot[0]));
+ TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
+ endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
+ -0.5*fgkEndCapCardElectBoardBackThickness,
+ fgkEndCapCardElectBoardBackWidth[0]
+ -endcapstripconnectionshape->GetDZ(),
+ 0.5*fgkEndCapCardElectBoardBackLength[0]);
+ endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
+ TGeoTranslation* cardinterfacetrans[9];
+ TGeoHMatrix* cardinterfacematrix[9];
+ for(Int_t i=0; i<7; i++){
+ cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
+ + fgkEndCapCardElectBoardBackThickness),
+ 0.0,0.0);
+ cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
+ * (*endcapstripconnectionmatrix));
+ }
+ cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
+ + fgkEndCapCardElectBoardBackThickness),
+ 0.0,0.0);
+ cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
+ * (*endcapstripconnectionmatrix));
+ cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
+ + fgkEndCapCardElectBoardBackThickness),
+ 0.0,0.0);
+ cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
+ * (*endcapstripconnectionmatrix));
+
+ for(Int_t i=0; i<4; i++){
+ cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
+ cardinterfacematrix[7]);
+ cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
+ cardinterfacematrix[8]);
+ }
+ TGeoTranslation* mothersupplycardtrans =
+ new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
+ + 2.*fgkEndCapCardJMDConnectorLength[0]
+ + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
+ TGeoHMatrix* mothersupplycardmatrix[7];
+ Int_t index[4] = {1,1,1,1};
+ for(Int_t i=0; i<7; i++){
+ mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
+ * (*mothersupplycardtrans));
+ for(Int_t j=0; j<4; j++){
+ switch(j){
+ case 0: //Layer5 EndCap Left Side
+ cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
+ cardinterfacematrix[i]);
+ if(i!=0){
+ cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
+ mothersupplycardmatrix[i]);
+ index[j]++;
+
+ }
+ break;
+ case 1: //Layer5 EndCap Rigth Side
+ cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
+ cardinterfacematrix[i]);
+ if(i>0&&i<6){
+ cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
+ mothersupplycardmatrix[i]);
+ index[j]++;
+ }
+ break;
+ case 2: //Layer6 EndCap Left Side
+ cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
+ cardinterfacematrix[i]);
+ if(i!=6){
+ cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
+ mothersupplycardmatrix[i]);
+ index[j]++;
+ }
+ break;
+ case 3: //Layer6 EndCap Right Side
+ cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
+ cardinterfacematrix[i]);
+ cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
+ mothersupplycardmatrix[i]);
+ index[j]++;
+ break;
+ }
+ }
+ }
+ // Positioning Interface
+ TGeoTranslation* motherinterfacecardtrans =
+ new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
+ +0.5*fgkEndCapCardElectBoardBackThickness
+ -fgkEndCapCardElectBoardLayerThickness
+ +fgkEndCapStripConnectionThickness,0.,0.);
+ for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
+ motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
+ // Positioning Interface Card B
+ TGeoTranslation* interfacecardBmothertrans =
+ new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
+ + 2.*fgkEndCapStripConnectionThickness
+ + fgkEndCapCardElectBoardBackThickness,0.,
+ -0.5 * (fgkEndCapInterfaceCardBLength[1]
+ - fgkEndCapCardElectBoardBackLength[0]));
+ for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
+ interfacecardBmothertrans);
+ // Positioning Stiffener
+ TGeoTranslation* endcapstiffenertrans =
+ new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
+ + 2.0*fgkEndCapStripConnectionThickness
+ + fgkEndCapInterfaceCardBThickness
+ + fgkEndCapCardJMDConnectorLength[0]
+ + stiffenertransx
+ + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
+ endcapstiffenershape->GetDZ()
+ - 0.5*(fgkEndCapStiffenerLength
+ - fgkEndCapCardElectBoardBackLength[0]));
+ for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete interfacecardBrot;
+ delete interfacecardBtrans;
+ delete electboardcardBtrans;
+ delete electboardcardBrot;
+ delete jmdconnectorcardBrot;
+ for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
+ delete jmdconnectorot;
+ delete jmdconnectortrans[1];
+ for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
+ delete cableconnectorcombitrans;
+ delete electboardbacktrans;
+ delete electboardbackrot;
+ delete electlayerrot;
+ for(Int_t i=0; i<2; i++) delete electlayertrans[i];
+ for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
+ delete mothersupplycardtrans;
+ for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
+ /////////////////////////////////////////////////////////////
+ return cardinterfacecontainer;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
+ /////////////////////////////////////////////////////////////
+ // Method returning EndCap Mother Volume
+ /////////////////////////////////////////////////////////////
+ const Int_t kendcapcoverplatesmallholenumber = 9;
+ Double_t endcapmotherorigin[3];
+ endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
+ + 0.5 *(fgkEndCapCoverPlateLength[3]
+ + 2.0 * fgkEndCapCoverPlateLength[2]);
+ endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2])
+ + 0.5*(fgkEndCapSideCoverLength[2]
+ + fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0])
+ - (fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]);
+ endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
+ + 2.*fgkEndCapCoolingTubeRadiusMax
+ - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
+ + fgkEndCapSideCoverWidth[1]
+ + fgkEndCapSideCoverThickness
+ + fgkEndCapKaptonFoilThickness);
+ TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
+ + 2.0* fgkEndCapCoverPlateLength[2]
+ + 2.0* fgkEndCapSideCoverThickness),
+ 0.5* (fgkEndCapSideCoverLength[2]
+ + fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]),
+ 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
+ + fgkEndCapSideCoverWidth[1]
+ + fgkEndCapSideCoverThickness
+ + fgkEndCapKaptonFoilThickness),
+ endcapmotherorigin);
+ TGeoVolume** endcapassembly;
+ endcapassembly = new TGeoVolume*[4];
+ endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
+ endcapmothershape,fSSDAir);
+ endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
+ endcapmothershape,fSSDAir);
+ endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
+ endcapmothershape,fSSDAir);
+ endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
+ endcapmothershape,fSSDAir);
+ /////////////////////////////////
+ // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
+ // endcapassembly[1]: Container End Cap Layer 5 Gex Side
+ // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
+ // endcapassembly[3]: Container End Cap Layer 6 Gex Side
+ /////////////////////////////////
+ /////////////////////////////////////////////////////
+ // Placing Endcap Cover Plate
+ /////////////////////////////////////////////////////
+ TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
+ TGeoRotation* endcapcoverplaterot = new TGeoRotation();
+ endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
+ TGeoCombiTrans* endcapcoverplatecombitrans =
+ new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
+ endcapcoverplaterot);
+ TGeoTranslation* endcapcoverplatetrans =
+ new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
+ TGeoHMatrix* endcapcoverplatematrix =
+ new TGeoHMatrix((*endcapcoverplatetrans)
+ * (*endcapcoverplatecombitrans));
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
+ /////////////////////////////////////////////////////
+ // Placing Endcap Side Cover
+ /////////////////////////////////////////////////////
+ TGeoVolume* endcapsidecover = GetEndCapSideCover();
+ TGeoRotation* endcapsidecoverot[2];
+ TGeoCombiTrans* endcapsidecovercombitrans[3];
+ for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
+ endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
+ endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
+ - 0.5*(fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2])
+ + 0.*fgkEndCapCoverPlateWidth[0]
+ + fgkEndCapSideCoverLength[2],
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness)
+ - 0.5*fgkEndCapCoverPlateThickness,
+ endcapsidecoverot[0]);
+ endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
+ endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
+ 0.5*fgkEndCapCoverPlateThickness
+ -fgkEndCapSideCoverWidth[1],
+ endcapsidecoverot[1]);
+ endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
+ +fgkEndCapCoverPlateLength[3]
+ +2.*fgkEndCapCoverPlateLength[2]
+ +fgkEndCapSideCoverThickness,0.0,
+ 0.5*fgkEndCapCoverPlateThickness
+ -fgkEndCapSideCoverWidth[1],
+ endcapsidecoverot[1]);
+ TGeoHMatrix* endcapsidecovermatrix[2];
+ for(Int_t i=0; i<2; i++){
+ endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
+ * (*endcapsidecovercombitrans[0]));
+ for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
+ endcapsidecovermatrix[i]);
+ }
+ /////////////////////////////////////////////////////
+ // Placing Endcap Cooling Tube
+ /////////////////////////////////////////////////////
+ TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
+ TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
+ endcapcoolingtuberot->SetAngles(0.,180.,0.);
+ TGeoCombiTrans* endcapccolingtubecombitrans
+ = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
+ + fgkEndCapCoolingTubeAxialRadius[1])
+ + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
+ - fgkEndCapCoolingTubeToCoverSide,
+ fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
+ + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
+ endcapccolingtubecombitrans);
+ /////////////////////////////////////////////////////
+ // Placing Screws
+ /////////////////////////////////////////////////////
+ Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
+ fgkEndCapCoverPlateScrewRadiusMin};
+ Int_t screwcoverplatedgesnumber[2] = {20,20};
+ Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
+ fgkEndCapCoverPlateThickness
+ + fgkEndCapCoolingTubeRadiusMax};
+ TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
+ screwcoverplatedgesnumber,
+ screwcoverplatesection);
+ TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
+ screwcoverplateshape,
+ fSSDCoolingTubePhynox);
+ screwcoverplate->SetLineColor(12);
+ Double_t transx[4] = {0,
+ fgkEndCapCoverPlateSmallHoleSeparation[0],
+ fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + fgkEndCapCoverPlateSmallHoleSeparation[1],
+ 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
+ + fgkEndCapCoverPlateSmallHoleSeparation[1]};
+ const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
+// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
+ TGeoTranslation*** endcapcoverplatescrewtrans;
+ endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
+ Int_t index = 0;
+ for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
+ endcapcoverplatescrewtrans[i] =
+ new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
+ for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
+ index = kendcapcoverplatescrewnumber[1]*i+j+1;
+ if(index==1||index==9||index==28||index==36){
+ endcapcoverplatescrewtrans[i][j] =
+ new TGeoTranslation(transx[i],
+ j*fgkEndCapCoverPlateSmallHoleSeparation[2],
+ fgkEndCapSideCoverThickness);
+ }
+ else{
+ endcapcoverplatescrewtrans[i][j] =
+ new TGeoTranslation(transx[i],
+ j*fgkEndCapCoverPlateSmallHoleSeparation[2],
+ 0.);
+ }
+ if(index!=19)
+ for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
+ endcapcoverplatescrewtrans[i][j]);
+ }
+ }
+ /////////////////////////////////////////////////////
+ // Placing Cover Plate Clips
+ /////////////////////////////////////////////////////
+ TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
+ 0.5*fgkEndCapCoverPlateClipWidth,
+ 0.5*fgkEndCapSideCoverThickness);
+ TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
+ endcapcoverplateclipshape,
+ fSSDCoolingTubePhynox);
+ TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
+ 0.5*fgkEndCapCoverPlateDownClipWidth,
+ 0.5*fgkEndCapSideCoverThickness);
+ TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
+ endcapcoverplatedownclipshape,
+ fSSDCoolingTubePhynox);
+ TGeoTranslation* endcapcoverplatecliptrans[4];
+ endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
+ - fgkEndCapCoverPlateLength[0]
+ - fgkEndCapSideCoverThickness,
+ 0.0,
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness));
+ endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
+ - fgkEndCapCoverPlateLength[0]
+ - fgkEndCapSideCoverThickness,
+ (kendcapcoverplatescrewnumber[1]-1)
+ * fgkEndCapSideCoverWidth[5],
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness));
+ endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
+ - fgkEndCapCoverPlateLength[0]
+ + fgkEndCapCoverPlateLength[1]
+ + 2.*fgkEndCapCoverPlateLength[0]
+ - fgkEndCapCoverPlateClipLength
+ + fgkEndCapSideCoverThickness,
+ 0.0,
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness));
+ endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
+ - fgkEndCapCoverPlateLength[0]
+ + fgkEndCapCoverPlateLength[1]
+ + 2.*fgkEndCapCoverPlateLength[0]
+ - fgkEndCapCoverPlateClipLength
+ + fgkEndCapSideCoverThickness,
+ (kendcapcoverplatescrewnumber[1]-1)
+ * fgkEndCapSideCoverWidth[5],
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness));
+ endcapcoverplateclip->SetLineColor(fColorPhynox);
+ endcapcoverplatedownclip->SetLineColor(fColorPhynox);
+ for(Int_t i=0; i<4; i++)
+ for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
+ endcapcoverplatecliptrans[i]);
+ TGeoTranslation* endcapcoverplatedowncliptrans[4];
+ endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
+ - fgkEndCapCoverPlateLength[0]
+ - fgkEndCapSideCoverThickness,
+ 0.5*(fgkEndCapCoverPlateDownClipWidth
+ - fgkEndCapCoverPlateClipWidth),
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness)
+ - fgkEndCapSideCoverWidth[1]
+ - fgkEndCapSideCoverThickness);
+ endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
+ - fgkEndCapCoverPlateLength[0]
+ - fgkEndCapSideCoverThickness,
+ 0.5*(fgkEndCapCoverPlateDownClipWidth
+ - fgkEndCapCoverPlateClipWidth)
+ + fgkEndCapSideCoverLength[2]
+ - fgkEndCapCoverPlateDownClipWidth,
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness)
+ - fgkEndCapSideCoverWidth[1]
+ - fgkEndCapSideCoverThickness);
+ endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
+ - fgkEndCapCoverPlateLength[0]
+ + fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateLength[1]
+ + 2.0*fgkEndCapCoverPlateLength[0]
+ - fgkEndCapCoverPlateDownClipLength,
+ 0.5*(fgkEndCapCoverPlateDownClipWidth
+ - fgkEndCapCoverPlateClipWidth),
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness)
+ - fgkEndCapSideCoverWidth[1]
+ - fgkEndCapSideCoverThickness);
+ endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
+ - fgkEndCapCoverPlateLength[0]
+ + fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateLength[1]
+ + 2.0*fgkEndCapCoverPlateLength[0]
+ - fgkEndCapCoverPlateDownClipLength,
+ 0.5*(fgkEndCapCoverPlateDownClipWidth
+ - fgkEndCapCoverPlateClipWidth)
+ + fgkEndCapSideCoverLength[2]
+ - fgkEndCapCoverPlateDownClipWidth,
+ 0.5*(fgkEndCapSideCoverThickness
+ + fgkEndCapCoverPlateThickness)
+ - fgkEndCapSideCoverWidth[1]
+ - fgkEndCapSideCoverThickness);
+ for(Int_t i=0; i<4; i++)
+ for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
+ endcapcoverplatedowncliptrans[i]);
+ /////////////////////////////////////////////////////
+ // Placing Kapton Foil
+ /////////////////////////////////////////////////////
+ TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
+ 0.5*fgkEndCapKaptonFoilWidth,
+ 0.5*fgkEndCapKaptonFoilThickness);
+ TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
+ endcapkaptonfoilshape,
+ fSSDKaptonFlexMedium);
+ endcapkaptonfoil->SetLineColor(8);
+ TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
+ 0.5*fgkEndCapKaptonFoilWidth
+ - 0.5*fgkEndCapCoverPlateClipWidth,
+ 0.5*fgkEndCapCoverPlateThickness
+ - 0.5*fgkEndCapKaptonFoilThickness
+ - fgkEndCapSideCoverWidth[1]
+ - fgkEndCapSideCoverThickness);
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
+ /////////////////////////////////////////////////////////////
+ // Placing Electronic Tubes
+ /////////////////////////////////////////////////////////////
+ Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
+ - fgkEndCapInterfaceCardBThickness
+ - 9.*fgkEndCapStripConnectionThickness
+ - 8.*fgkEndCapCardElectBoardBackThickness,
+ fgkEndCapKaptonFoilWidth
+ - fgkEndCapInterfaceCardBThickness
+ - 9.*fgkEndCapStripConnectionThickness
+ - 8.*fgkEndCapCardElectBoardBackThickness
+ - fgkEndCapInterfaceElectBoardCardBThickness};
+ TGeoVolume* endcapeffectivecables[2];
+ endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
+ fgkEndCapEffectiveCableRadiusMax,
+ endcapeffectivecableswidth[0],
+ 10,"EndCapEffectiveCables1");
+ endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
+ fgkEndCapEffectiveCableRadiusMax,
+ endcapeffectivecableswidth[1],
+ 25,"EndCapEffectiveCables2");
+ TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
+ TGeoTranslation* endcapeffectivecablestrans[2];
+ endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
+ - 0.5*endcapeffectivecableswidth[0]
+ - 0.5*(fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2])
+ + fgkEndCapSideCoverLength[2],
+ - 0.5*fgkEndCapCoverPlateThickness
+ - (fgkEndCapCardElectBoardBackWidth[0]
+ - fgkEndCapInterfaceCardBWidth[0]
+ - fgkEndCapInterfaceCardBWidth[1]));
+ endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
+ - 0.5*endcapeffectivecableswidth[1]
+ - 0.5*(fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2])
+ + fgkEndCapSideCoverLength[2],
+ - 0.5*fgkEndCapCoverPlateThickness
+ - (fgkEndCapCardElectBoardBackWidth[0]
+ - fgkEndCapInterfaceCardBWidth[0])
+ - 0.5*fgkEndCapInterfaceCardBWidth[2]);
+ endcapeffectivecablesrot->SetAngles(0.,90.,0.);
+ TGeoCombiTrans* endcapeffectivecablescombitrans[2];
+ endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
+ *endcapeffectivecablesrot);
+ endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
+ *endcapeffectivecablesrot);
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
+ endcapeffectivecablescombitrans[0]);
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
+ endcapeffectivecablescombitrans[1]);
+ /////////////////////////////////////////////////////////////
+ // Placing End Cap Cards
+ /////////////////////////////////////////////////////////////
+ TGeoVolume** endcapcards = GetEndCapCards();
+ TGeoRotation* endcapcardsrot[2];
+ for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
+ endcapcardsrot[0]->SetAngles(90.,0.,0.);
+ TGeoTranslation* endcapcardstrans[2];
+ endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
+ - fgkEndCapCardElectBoardBackLength[0]));
+ TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
+ endcapcardsrot[1]->SetAngles(90.,90.,-90.);
+ TGeoHMatrix* endcapcardsmatrix[2];
+ endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
+ Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
+ - fgkEndCapCardJMDConnectorLength[0]
+ - fgkEndCapInterfaceCardBThickness
+ - 9.*fgkEndCapStripConnectionThickness
+ - 8.*fgkEndCapCardElectBoardBackThickness;
+ endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
+ - fgkEndCapCoverPlateLength[0]
+ + 0.5 * (fgkEndCapCoverPlateLength[3]
+ + 2.0 * fgkEndCapCoverPlateLength[2]),
+ - stiffenertransx-fgkEndCapStiffenerWidth
+ - fgkEndCapCardJMDConnectorLength[0]
+ - fgkEndCapInterfaceCardBThickness
+ - 2.0 * fgkEndCapStripConnectionThickness
+ - 1.5 * fgkEndCapInterfaceCardBThickness
+ - 0.5 * (fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2])
+ + fgkEndCapKaptonFoilWidth,
+ 0.5*fgkEndCapCoverPlateThickness
+ - fgkEndCapSideCoverWidth[1]);
+ endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
+ for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete endcapcoverplaterot;
+ delete endcapcoverplatecombitrans;
+ delete endcapcoverplatetrans;
+ for(Int_t i=0; i<3; i++){
+ delete endcapsidecovercombitrans[i];
+ if(i<2) delete endcapsidecoverot[i];
+ }
+ for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
+ for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
+ delete endcapcardsmatrix[0];
+ return endcapassembly;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
+ Double_t radiusmax,
+ Double_t width,
+ Int_t ncables,
+ char* volname){
+ /////////////////////////////////////////////////////////////
+ // Generating EndCap High Voltage Tubes
+ /////////////////////////////////////////////////////////////
+ Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
+ Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
+ + TMath::Power(radiusmax,2.)
+ - TMath::Power(radiusmin,2.));
+ TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
+ TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
+ effectiveouteradius,0.5*width);
+ TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
+ effectiveinnertubeshape,
+ fSSDStiffenerConnectorMedium);
+ effectiveinnertube->SetLineColor(41);
+ TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
+ effectiveoutertubeshape,
+ fSSDKaptonChipCableMedium);
+ effectiveoutertube->SetLineColor(39);
+ TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
+ TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
+ effectivemothertube->AddNode(effectiveinnertube,1);
+ effectivemothertube->AddNode(effectiveoutertube,1);
+ return effectivemothertube;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
+ /////////////////////////////////////////////////////////////
+ // Generating EndCap Support Layer 5 and Layer 6
+ /////////////////////////////////////////////////////////////
+ const Int_t knedges = 5;
+ ///////////////////////////////////////////////
+ // Setting the vertices for TGeoXtru Up Volume
+ ///////////////////////////////////////////////
+ const Int_t klayernumber = 2;
+ Double_t xupvertex[klayernumber][knedges+3];
+ Double_t yupvertex[klayernumber][knedges+3];
+ Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
+ Double_t middledgeangle[klayernumber] = {0.0,0.0};
+ Double_t middlepsi[klayernumber] = {0.0,0.0};
+ for(Int_t i=0; i<klayernumber; i++){
+ xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
+ xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
+ xupvertex[i][2] = -xupvertex[i][1];
+ xupvertex[i][3] = -xupvertex[i][0];
+
+ yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
+ yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
+ yupvertex[i][2] = yupvertex[i][1];
+ yupvertex[i][3] = yupvertex[i][0];
+
+ middledgeangle[i] = upedgeangle[i]/knedges;
+ middlepsi[i] = 90.0-0.5*upedgeangle[i];
+ for(Int_t j=1; j<knedges; j++){
+ xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
+ yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
+ }
+ }
+ ////////////////////////////////////
+ // Generating Up TGeoXtru
+ ////////////////////////////////////
+ TGeoXtru* upendcapsupportshape[klayernumber];
+ TGeoVolume* upendcapsupport[klayernumber];
+ char upendcapsupportname[30];
+ for(Int_t i=0; i<klayernumber; i++){
+ upendcapsupportshape[i] = new TGeoXtru(2);
+ sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
+ upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
+ upendcapsupportshape[i]->DefineSection(0,0.);
+ upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
+ upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
+ fSSDCoolingTubePhynox);
+// upendcapsupport[i]->SetLineColor(fColorPhynox);
+ upendcapsupport[i]->SetLineColor(5);
+ }
+ ///////////////////////////////////////////////
+ // Setting the vertices for TGeoXtru Down Volume
+ ///////////////////////////////////////////////
+ Double_t xdownvertex[klayernumber][2*(knedges+1)];
+ Double_t ydownvertex[klayernumber][2*(knedges+1)];
+ for(Int_t i=0; i<klayernumber; i++){
+ xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
+ xdownvertex[i][1] = xupvertex[i][0];
+ ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
+ ydownvertex[i][1] = yupvertex[i][0];
+ for(Int_t j=0; j<knedges; j++){
+ xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
+ ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
+ }
+ for(Int_t j=0; j<knedges; j++){
+ xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
+ * CosD(middlepsi[i]+j*middledgeangle[i]);
+ ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
+ * SinD(middlepsi[i]+j*middledgeangle[i]);
+ }
+ }
+ ////////////////////////////////////
+ // Generating Down TGeoXtru
+ ////////////////////////////////////
+ TGeoXtru* downendcapsupportshape[klayernumber];
+ TGeoVolume* downendcapsupport[klayernumber];
+ char downendcapsupportname[30];
+ for(Int_t i=0; i<klayernumber; i++){
+ downendcapsupportshape[i] = new TGeoXtru(2);
+ sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
+ downendcapsupportshape[i] = new TGeoXtru(2);
+ downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
+ if(i==0){
+ downendcapsupportshape[i]->DefineSection(0,0.);
+ downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
+ }
+ else{
+ downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
+ - fgkEndCapSupportLowWidth[i]);
+ downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
+ }
+ downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
+ downendcapsupportshape[i],fSSDCoolingTubePhynox);
+// downendcapsupport[i]->SetLineColor(fColorPhynox);
+ downendcapsupport[i]->SetLineColor(5);
+ }
+ ///////////////////////////////////////////////
+ // Setting TGeoPgon Volume
+ ///////////////////////////////////////////////
+ const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
+ fgkSSDLay6LadderNumber};
+ TGeoPgon* endcapsupportmothershape[klayernumber];
+ TGeoVolume** endcapsupportmother;
+ endcapsupportmother = new TGeoVolume*[klayernumber];
+ char endcapsupportmothername[30];
+ for(Int_t i=0; i<klayernumber; i++){
+ endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
+ sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
+ endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
+ endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
+ ydownvertex[i][0],yupvertex[i][1]);
+ endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
+ fSSDCoolingTubePhynox);
+ }
+ ////////////////////////////////////
+ TGeoRotation** endcapsupportrot[klayernumber];
+ for(Int_t i=0; i<2; i++){
+ endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ endcapsupportrot[i][j] = new TGeoRotation();
+ endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
+ endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
+ endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
+ }
+ }
+ return endcapsupportmother;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
+ /////////////////////////////////////////////////////////////
+ // Setting End Cap Support Layer 5 and 6.
+ /////////////////////////////////////////////////////////////
+ const Int_t kendcapcoverplatesmallholenumber = 9;
+ const Int_t klayernumber = 2;
+ const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
+ fgkSSDLay6LadderNumber};
+ Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
+ 360.0/kssdlayladdernumber[1]};
+ TGeoVolume** endcapsupport = EndCapSupport();
+ TGeoVolume** endcapassembly = GetEndCapAssembly();
+ TGeoPgon* endcapsupportshape[klayernumber];
+ Double_t* radiusmin[klayernumber];
+ Double_t* radiusmax[klayernumber];
+ for(Int_t i=0; i<klayernumber; i++){
+ endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
+ radiusmin[i] = endcapsupportshape[i]->GetRmin();
+ radiusmax[i] = endcapsupportshape[i]->GetRmax();
+ }
+ TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
+ Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
+ endcapassemblyshape->GetDY(),
+ endcapassemblyshape->GetDZ()};
+ ///////////////////////////////////////////////
+ // Setting TGeoPgon Volume for Mother Container
+ ///////////////////////////////////////////////
+ TGeoPgon* endcapsupportsystemshape[klayernumber];
+ char endcapsupportsystemothername[30];
+ for(Int_t i=0; i<klayernumber; i++){
+ endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
+ sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
+ endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
+ (*radiusmax[i]*CosD(0.5*upedgeangle[i])
+ +2.*endcapassemblycenter[2])
+ /CosD(0.5*upedgeangle[i]));
+ endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
+ -(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]),
+ *radiusmin[i],
+ (*radiusmax[i]*CosD(0.5*upedgeangle[i])
+ +2.*endcapassemblycenter[2])
+ /CosD(0.5*upedgeangle[i]));
+ }
+ fgkEndCapSupportSystem = new TGeoVolume*[4];
+ fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
+ endcapsupportsystemshape[0],fSSDAir);
+ fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
+ endcapsupportsystemshape[0],fSSDAir);
+ fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
+ endcapsupportsystemshape[1],fSSDAir);
+ fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
+ endcapsupportsystemshape[1],fSSDAir);
+ ///////////////////////////////////////////////
+ TGeoTranslation* endcapassemblytrans[klayernumber];
+ for(Int_t i=0; i<klayernumber; i++)
+ endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
+ - fgkEndCapSideCoverThickness
+ + endcapassemblycenter[0],
+ - 0.5*fgkEndCapCoverPlateThickness
+ - 2.0*fgkEndCapCoolingTubeRadiusMax
+ + 2.0*endcapassemblycenter[2]
+ + 0.5*fgkEndCapSupportLength[i]
+ / TanD(0.5*upedgeangle[i]),
+ 0.5*(fgkEndCapCoverPlateWidth[0]
+ - fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]));
+ TGeoRotation** endcapassemblyrot[klayernumber];
+ TGeoHMatrix** endcapassemblymatrix[klayernumber];
+ for(Int_t i=0; i<klayernumber; i++){
+ endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
+ endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
+ for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
+ endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
+ endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
+ endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
+ endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
+ for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
+ endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
+ endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
+ }
+ }
+ TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
+ fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
+ for(Int_t i=0; i<2*klayernumber; i++){
+ for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
+ fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
+ endcapassemblymatrix[1][j+2]);
+ }
+ fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
+ }
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<klayernumber; i++){
+ for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
+ delete endcapassemblyrot[i][j];
+ }
+ delete endcapassemblyrot[i];
+ delete endcapassemblymatrix[i][0];
+ delete endcapassemblymatrix[i][1];
+ }
+ /////////////////////////////////////////////////////////////
+ }
+ void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Setting End Cap Support + End Cap Assembly of Layer 5.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
+ return;
+ };
+ if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
+ TGeoTranslation* endcapsupportsystemITSCentertrans[2];
+ endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
+ fgkEndCapSupportCenterLay5ITSPosition
+ + fgkEndCapSupportCenterLay5Position
+ - fgkEndCapSideCoverLength[2]);
+ endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
+ fgkEndCapSideCoverLength[2]
+ - fgkEndCapSupportCenterLay5Position
+ - fgkEndCapSupportCenterLay5ITSPosition);
+ TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
+ endcapsupportsystemrot->SetAngles(90.,180.,-90.);
+ TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
+ new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
+ moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
+ moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete endcapsupportsystemrot;
+ delete endcapsupportsystemITSCentertrans[1];
+ }
+ /////////////////////////////////////////////////////////////
+ void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Setting End Cap Support + End Cap Assembly of Layer 6.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
+ return;
+ };
+ if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
+ TGeoTranslation* endcapsupportsystemITSCentertrans[2];
+ endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
+ fgkEndCapSupportCenterLay6ITSPosition
+ + fgkEndCapSupportCenterLay6Position
+ - fgkEndCapSideCoverLength[2]);
+ endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
+ fgkEndCapSideCoverLength[2]
+ - fgkEndCapSupportCenterLay6Position
+ - fgkEndCapSupportCenterLay6ITSPosition);
+ TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
+ endcapsupportsystemrot->SetAngles(90.,180.,-90.);
+ TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
+ new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
+ moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
+ moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete endcapsupportsystemrot;
+ delete endcapsupportsystemITSCentertrans[1];
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Setting Ladder Support of Layer 5.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
+ return;
+ };
+ if(!fLay5LadderSupportRing) SetLadderSupport(100);
+ fMotherVol = moth;
+ TGeoTranslation* centerITSRingSupportLay5trans[2];
+ for(Int_t i=0; i<2; i++){
+ centerITSRingSupportLay5trans[i] =
+ new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
+ moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
+ /////////////////////////////////////////////////////////////
+ // Setting Ladder Support of Layer 6.
+ /////////////////////////////////////////////////////////////
+ if (! moth) {
+ printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
+ return;
+ };
+ if(!fLay6LadderSupportRing) SetLadderSupport(100);
+ fMotherVol = moth;
+ TGeoTranslation* centerITSRingSupportLay6trans[2];
+ for(Int_t i=0; i<2; i++){
+ centerITSRingSupportLay6trans[i] =
+ new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
+ moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////////
TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
- Double_t height, char* shapename, Int_t isign){
- const Int_t VertexNumber = 8;
- const Int_t TransVectNumber = 2;
- TVector3* Vertex[VertexNumber];
- TVector3* TransVector[2];
- for(Int_t i=0; i<TransVectNumber; i++) TransVector[i] = new TVector3(0.,width[i]);
-////////////////////////////////////////////////////////////////////////////////
+ Double_t height, char* shapename, Int_t isign) const{
+ /////////////////////////////////////////////////////////////
+ // Method generating an Arb shape
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 8;
+ const Int_t ktransvectnumber = 2;
+ TVector3* vertex[kvertexnumber];
+ TVector3* transvector[2];
+ for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
+ /////////////////////////////////////////////////////////////
//Setting the vertices for TGeoArb8
-////////////////////////////////////////////////////////////////////////////////
- Vertex[0] = new TVector3(*vertexpos[0]);
- Vertex[1] = new TVector3(*vertexpos[1]);
- Vertex[2] = new TVector3(*Vertex[1]+isign*(*TransVector[0]));
- Vertex[3] = new TVector3(*Vertex[0]+isign*(*TransVector[0]));
- Vertex[4] = new TVector3(*vertexpos[2]);
- Vertex[5] = new TVector3(*vertexpos[3]);
- Vertex[6] = new TVector3(*Vertex[5]+isign*(*TransVector[1]));
- Vertex[7] = new TVector3(*Vertex[4]+isign*(*TransVector[1]));
-////////////////////////////////////////////////////////////////////////////////
- TGeoArb8* ArbShape = new TGeoArb8(shapename,0.5*height);
- for(Int_t i = 0; i<VertexNumber;i++)
- ArbShape->SetVertex(i,Vertex[i]->X(),Vertex[i]->Y());
- return ArbShape;
+ /////////////////////////////////////////////////////////////
+ vertex[0] = new TVector3(*vertexpos[0]);
+ vertex[1] = new TVector3(*vertexpos[1]);
+ vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
+ vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
+ vertex[4] = new TVector3(*vertexpos[2]);
+ vertex[5] = new TVector3(*vertexpos[3]);
+ vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
+ vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
+ /////////////////////////////////////////////////////////////
+ TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
+ for(Int_t i = 0; i<kvertexnumber;i++)
+ arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
+ for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
+ /////////////////////////////////////////////////////////////
+ return arbshape;
}
+///////////////////////////////////////////////////////////////////////////////
+TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
+ Double_t rmax, Int_t nedges, Double_t height){
+ /////////////////////////////////////////////////////////////
+ // Method generating Arc shape
+ /////////////////////////////////////////////////////////////
+ const Int_t kvertexnumber = 2*nedges+2;
+ TGeoXtru* arcshape = new TGeoXtru(2);
+ TVector3** vertexposition[2];
+ for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
+ Double_t angle = 0.;
+ for(Int_t i=0; i<nedges+1; i++){
+ angle = 90.+0.5*phi-i*(phi/nedges);
+ vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
+ vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
+ }
+ Double_t *xvertexpoints = new Double_t[kvertexnumber];
+ Double_t *yvertexpoints = new Double_t[kvertexnumber];
+ for(Int_t i=0; i<kvertexnumber; i++){
+ if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
+ yvertexpoints[i] = vertexposition[0][i]->Y();
+ }
+ else if(i>=1&&i<nedges+2)
+ {
+ xvertexpoints[i] = vertexposition[1][i-1]->X();
+ yvertexpoints[i] = vertexposition[1][i-1]->Y();
+ }
+ else
+ {
+ xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
+ yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
+ }
+ }
+ arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
+ arcshape->DefineSection(0,-0.5*height);
+ arcshape->DefineSection(1,0.5*height);
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ for(Int_t i=0; i<2; i++){
+ for(Int_t j=0; j<nedges+1; j++)
+ delete vertexposition[i][j];
+ delete [] vertexposition[i];
+ }
+ delete [] xvertexpoints;
+ delete [] yvertexpoints;
+ /////////////////////////////////////////////////////////////
+ return arcshape;
+}
////////////////////////////////////////////////////////////////////////////////
-TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[],
- Double_t height, char* shapename){
-////////////////////////////////////////////////////////////////////////////////
- const Int_t VertexNumber = 4;
- TVector3* Vertex[VertexNumber];
-//////////////////////////////////////
- //Setting the vertices for TGeoArb8
- ////////////////////////////////////
- for(Int_t i = 0; i<VertexNumber; i++)
- Vertex[i] = new TVector3(i!=VertexNumber-1?*vertexpos[i]:*Vertex[VertexNumber-1-i]);
- TGeoArb8* TriangleShape = new TGeoArb8(shapename,0.5*height);
- for(Int_t i = 0; i<2*VertexNumber; i++)
- TriangleShape->SetVertex(i,Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
- Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
- return TriangleShape;
+TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
+ ///////////////////////////////////////////////////////////////////////
+ // Method Generating the Screw Shape
+ // radius[0]: outer radius
+ // radius[1]: inner radius
+ // edgesnumber[0]: outer number of edges
+ // edgesnumber[1]: inner number of edges
+ // section[0]: lower section position
+ // section[1]: higher section position
+ ///////////////////////////////////////////////////////////////////////
+ Double_t outradius = radius[0];
+ Double_t inradius = radius[1];
+ Int_t outvertexnumber = edgesnumber[0];
+ Int_t invertexnumber = edgesnumber[1];
+ Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
+ Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
+ for(Int_t i=0; i<outvertexnumber+1; i++){
+ xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
+ yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
+ }
+ for(Int_t i=0; i<invertexnumber+1; i++){
+ xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
+ yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
+ }
+ TGeoXtru* screwshape = new TGeoXtru(2);
+ screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
+ screwshape->DefineSection(0,section[0]);
+ screwshape->DefineSection(1,section[1]);
+ delete [] xscrewvertex;
+ delete [] yscrewvertex;
+ return screwshape;
}
////////////////////////////////////////////////////////////////////////////////
-TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* Vector,Double_t* Param){
+TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
+ ///////////////////////////////////////////////////////////////////////
+ // Method Generating the Hole Shape
+ // radius of the Hole
+ // nedges: number of edges to approximate the circle
+ ///////////////////////////////////////////////////////////////////////
+ Int_t vertexnumber = nedges+6;
+ Double_t* xholevertex = new Double_t[vertexnumber];
+ Double_t* yholevertex = new Double_t[vertexnumber];
+ xholevertex[0] = radius;
+ xholevertex[1] = xholevertex[0];
+ xholevertex[2] = -xholevertex[1];
+ xholevertex[3] = xholevertex[2];
+ xholevertex[4] = xholevertex[0];
+ yholevertex[0] = 0.;
+ yholevertex[1] = -radius;
+ yholevertex[2] = yholevertex[1];
+ yholevertex[3] = -yholevertex[1];
+ yholevertex[4] = yholevertex[3];
+ for(Int_t i=0; i<nedges+1; i++){
+ xholevertex[i+5] = radius*CosD(i*360./nedges);
+ yholevertex[i+5] = radius*SinD(i*360./nedges);
+ }
+ TGeoXtru* holeshape = new TGeoXtru(2);
+ holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
+ holeshape->DefineSection(0,section[0]);
+ holeshape->DefineSection(1,section[1]);
+ delete [] xholevertex;
+ delete [] yholevertex;
+ return holeshape;
+}
////////////////////////////////////////////////////////////////////////////////
- TVector3* n = new TVector3(Param[0],Param[1],Param[2]);
- Double_t D = ((*Vector)*(*n)+Param[3])/n->Mag2();
- TVector3* ReflectedVector = new TVector3(*Vector-2*D*(*n));
- return ReflectedVector;
+TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
+ /////////////////////////////////////////////////////////////
+ // Given an axis specified by param, it gives the reflection of the point
+ // respect to the axis
+ /////////////////////////////////////////////////////////////
+ TVector3* n = new TVector3(param[0],param[1],param[2]);
+ Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
+ TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
+ /////////////////////////////////////////////////////////////
+ // Deallocating memory
+ /////////////////////////////////////////////////////////////
+ delete n;
+ /////////////////////////////////////////////////////////////
+ return reflectedvector;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
+TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
Double_t dx,
Double_t dy,
Double_t dz) const{
- TGeoCombiTrans* CombiTrans = new TGeoCombiTrans(*ct);
+ /////////////////////////////////////////////////////////////
// Add a dx,dy,dz translation to the initial TGeoCombiTrans
- const Double_t *vect = CombiTrans->GetTranslation();
- Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
- CombiTrans->SetTranslation(newVect);
- return CombiTrans;
+ /////////////////////////////////////////////////////////////
+ TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
+ const Double_t *vect = hmatrix->GetTranslation();
+ Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
+ hmatrix->SetTranslation(newvect);
+ TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
+ delete hmatrix;
+ return matrix;
}
////////////////////////////////////////////////////////////////////////////////
-//To be interfaced with AliRoot Materials file
-////////////////////////////////////////////////////////////////////////////////
TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
+ /////////////////////////////////////////////////////////////
+ // Method returning the Medium type
+ /////////////////////////////////////////////////////////////
char ch[30];
sprintf(ch, "ITS_%s",mediumName);
TGeoMedium* medium = gGeoManager->GetMedium(ch);
return medium;
}
////////////////////////////////////////////////////////////////////////////////
-//To be interfaced with AliRoot Materials file
-////////////////////////////////////////////////////////////////////////////////
-/*void AliITSv11GeometrySSD::CreateMaterials(){
-///////////////////////////////////
-// This part has to be modified
-///////////////////////////////////
-// Float_t ifield = 2.000;
-// Float_t fieldm = 10.000;
-// Int_t ifield = gAlice->Field()->Integ();
-// Float_t fieldm = gAlice->Field()->Max();
- ///////////////////////////////////
- // Silicon for Sensor
- ///////////////////////////////////
- Int_t SINumber = 0;
- TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
- TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
- fgkSSDSensorMedium = Silicon;
- ///////////////////////////////////
- // Silicon Mixture for Sensor
- ///////////////////////////////////
- Int_t SiMixtureNumber = 1;
- TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
- TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
- fgkSSDChipMedium = SiliconMixture;
- ///////////////////////////////////
- // Stiffener Components Materials
- ///////////////////////////////////
- Int_t K1100Number = 2;
- TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
- TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
- fgkSSDStiffenerMedium = K1100;
- ///////////////////////////
- // Stiffener Connectors
- ///////////////////////////
- Int_t SnMaterialNumber = 3;
- TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
- TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
- SnMaterial);
- fgkSSDStiffenerConnectorMedium = SnMedium;
- ////////////////////////////////
- // Stiffener 0603-1812 Capacitor
- ////////////////////////////////
- Int_t Al2O3Number = 4;
- TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
- TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
- Al2O3Number,
- Al2O3Material);
- fgkSSDStiffener0603CapacitorMedium = Al2O3Medium;
- fgkSSDStiffener1812CapacitorMedium = Al2O3Medium;
- ///////////////////////////
- // Stiffener Hybrid Wire
- ///////////////////////////
- Int_t CuHybridWireNumber = 5;
- TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
- TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
- CuHybridWireNumber,
- CuHybridWireMaterial);
- fgkSSDStiffenerHybridWireMedium = CuHybridWireMedium;
- ///////////////////////////
- // Al for Cooling Block
- ///////////////////////////
- Int_t AlCoolBlockNumber = 6;
- TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
- TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
- AlCoolBlockNumber,
- AlCoolBlockMaterial);
- fgkSSDAlCoolBlockMedium = AlCoolBlockMedium;
- //////////////////////////////////////////////////////
- // Kapton and Al for Chip Cable Flex and Ladder Cables
- //////////////////////////////////////////////////////
- Int_t KaptonBlockNumber = 7;
- TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
- TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
- KaptonBlockNumber,
- KaptonMaterial);
- Int_t AlTraceBlockNumber = 8;
- TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
- TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
- AlTraceBlockNumber,
- AlTraceMaterial);
- fgkSSDKaptonChipCableMedium = KaptonMedium;
- fgkSSDAlTraceChipCableMedium = AlTraceMedium;
- fgkSSDKaptonFlexMedium = KaptonMedium;
- fgkSSDAlTraceFlexMedium = AlTraceMedium;
- fgkSSDKaptonLadderCableMedium = KaptonMedium;
- fgkSSDAlTraceLadderCableMedium = AlTraceMedium;
- /////////////////////////////////////////////////////////////////
- // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
- //////////////////////////////////////////////////////////////////
- Int_t M55JNumber = 9;
- TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
- TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
- M55JMaterial);
- fgkSSDCarbonFiberMedium = M55JMedium;
- fgkSSDMountingBlockMedium = M55JMedium;
- /////////////////////////////////////////////////////////////////
- // G10 for Detector Leg, TubeHolder
- //////////////////////////////////////////////////////////////////
- Int_t G10Number = 10;
- TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
- TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
- G10Material);
- fgkSSDTubeHolderMedium = G10Medium;
- fgkSSDSensorSupportMedium = G10Medium;
- /////////////////////////////////////////////////////////////////
- // Water and Phynox for Cooling Tube
- //////////////////////////////////////////////////////////////////
- Int_t WaterNumber = 11;
- TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
- TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
- WaterMaterial);
- fgkSSDCoolingTubeWater = WaterMedium;
- Int_t PhynoxNumber = 12;
- TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
- TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
- PhynoxMaterial);
- fgkSSDCoolingTubePhynox = PhynoxMedium;
-}
-*/
void AliITSv11GeometrySSD::CreateMaterials(){
///////////////////////////////////
// This part has to be modified
///////////////////////////////////
// Silicon for Sensor
///////////////////////////////////
- fgkSSDSensorMedium = GetMedium("Si");
+ fSSDSensorMedium = GetMedium("SI$");
///////////////////////////////////
// Silicon Mixture for Sensor
///////////////////////////////////
- fgkSSDChipMedium = GetMedium("SPD SI CHIP$");
- fgkSSDChipGlueMedium = GetMedium("EPOXY$");
+ fSSDChipMedium = GetMedium("SPD SI CHIP$");
+ fSSDChipGlueMedium = GetMedium("EPOXY$");
///////////////////////////////////
// Stiffener Components Materials
///////////////////////////////////
- fgkSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
+ fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
///////////////////////////
// Stiffener Connectors
///////////////////////////
- fgkSSDStiffenerConnectorMedium = GetMedium("COPPER");
+ fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
////////////////////////////////
// Stiffener 0603-1812 Capacitor
////////////////////////////////
- fgkSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
- fgkSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
+ fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
+ fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
///////////////////////////
// Stiffener Hybrid Wire
///////////////////////////
- fgkSSDStiffenerHybridWireMedium = GetMedium("COPPER");
+ fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
///////////////////////////
// Al for Cooling Block
///////////////////////////
- fgkSSDAlCoolBlockMedium = GetMedium("ITSal");
+ fSSDAlCoolBlockMedium = GetMedium("AL$");
//////////////////////////////////////////////////////
// Kapton and Al for Chip Cable Flex and Ladder Cables
//////////////////////////////////////////////////////
- fgkSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
- fgkSSDAlTraceChipCableMedium = GetMedium("ITSal");
- fgkSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
- fgkSSDAlTraceFlexMedium = GetMedium("ITSal");
- fgkSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
- fgkSSDAlTraceLadderCableMedium = GetMedium("ITSal");
+ fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
+ fSSDAlTraceChipCableMedium = GetMedium("AL$");
+ fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
+ fSSDAlTraceFlexMedium = GetMedium("AL$");
+ fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
+ fSSDAlTraceLadderCableMedium = GetMedium("AL$");
/////////////////////////////////////////////////////////////////
// M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
//////////////////////////////////////////////////////////////////
- fgkSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
+ fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
/////////////////////////////////////////////////////////////////
// G10 for Detector Leg, TubeHolder
//////////////////////////////////////////////////////////////////
- fgkSSDTubeHolderMedium = GetMedium("G10FR4$");
- fgkSSDSensorSupportMedium = GetMedium("G10FR4$");
- fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
- fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
+ fSSDTubeHolderMedium = GetMedium("G10FR4$");
+ fSSDSensorSupportMedium = GetMedium("G10FR4$");
+ fSSDMountingBlockMedium = GetMedium("G10FR4$");
+ fSSDMountingBlockMedium = GetMedium("G10FR4$");
/////////////////////////////////////////////////////////////////
// Water and Phynox for Cooling Tube
//////////////////////////////////////////////////////////////////
- fgkSSDCoolingTubeWater = GetMedium("WATER");
- fgkSSDCoolingTubePhynox = GetMedium("INOX$");
+ fSSDCoolingTubeWater = GetMedium("WATER$");
+ fSSDCoolingTubePhynox = GetMedium("INOX$");
+ /////////////////////////////////////////////////////////////////////
+ // Material for Support Rings
+ /////////////////////////////////////////////////////////////////////
+ fSSDSupportRingAl = GetMedium("AL$");
+ /////////////////////////////////////////////////////////////////////
+ fSSDAir = GetMedium("SDD AIR$");
+ fCreateMaterials = kTRUE;
}
/////////////////////////////////////////////////////////////////////
+