#include "TGeoPcon.h"
#include "TRotation.h"
#include "AliITSv11GeometrySSD.h"
-#include "Riostream.h"
+
/////////////////////////////////////////////////////////////////////////////////
// Names of the Sensitive Volumes of Layer 5 and Layer 6
/////////////////////////////////////////////////////////////////////////////////
-const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
-const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
+const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
+const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6";
/////////////////////////////////////////////////////////////////////////////////
//Parameters for SSD Geometry
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
// For ladders:
-const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.2*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Layer5 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
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*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder
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::fgkSSDCapacitor1812CapLength = 0.215*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::fgkSSDCapacitor1812Height = 1.400*fgkmm;
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::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::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Cooling Block (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
{1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
- {1.000*fgkmm, 0.120*fgkmm};
+ {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
{1.900*fgkmm, 0.400*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
// SSD Ladder Cable (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
/////////////////////////////////////////////////////////////////////////////////
// SSD Module (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
// Cooling Tube (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
-const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
fgkCarbonFiberJunctionWidth;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
1.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
6.0*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
4.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
{ 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
+ 0.5*fgkCoolingTubeSupportHeight
+ fgkSSDModuleCoolingBlockToSensor
- fgkMountingBlockSupportRadius[1]};
-const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
+const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.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::fgkEndCapSupportCenterLay5ITSPosition = 624.9*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;
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeigth = 87.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
fSSDStiffenerConnectorMedium(),
fSSDStiffener0603CapacitorMedium(),
fSSDStiffener1812CapacitorMedium(),
+ fSSDStiffenerCapacitorCapMedium(),
fSSDStiffenerHybridWireMedium(),
fSSDKaptonFlexMedium(),
fSSDAlTraceFlexMedium(),
fSSDRohaCellCone(),
fSSDAir(),
fSSDCopper(),
+ fSSDSn(),
fCreateMaterials(kFALSE),
fTransformationMatrices(kFALSE),
fBasicObjects(kFALSE),
fcoolingblocksystematrix(),
fssdstiffenerflex(),
fssdendflex(),
+ fcoolingtube(0),
fendladdercoolingtubesupportmatrix(),
fendladdermountingblock(),
fendladdermountingblockclip(),
fColorPhynox(14),
fColorSilicon(3),
fColorAl(38),
+ fColorNiSn(40),
fColorKapton(6),
fColorPolyhamide(5),
fColorStiffener(9),
////////////////////////
// Standard constructor
////////////////////////
+ for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
+ fendladdermountingblockcombitrans[i] = NULL;
+ }
+ for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
+ fcarbonfibersupport[i] = 0;
+ fcarbonfibersupportmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
+ fcarbonfiberjunctionmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
+ fcarbonfiberlowersupport[i] = 0;
+ fcarbonfiberlowersupportrans[0] = 0;
+ }
+ for (Int_t i=0; i < fgkvolumekind; i++) {
+ fssdsensorsupport[i] = 0;
+ }
+ for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
+ fssdsensorsupportmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
+ fcoolingtubesupportmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkhybridcompnumber; i++) {
+ fssdhybridcomponent[i] = 0;
+ }
+ for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
+ fcoolingblockmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkflexnumber; i++) {
+ fstiffenerflexmatrix[i] = 0;
+ fendflexmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
+ fendladdercoolingtube[i] = 0;
+ for (Int_t j = 0; j < 2; j++)
+ fendladdercoolingtubematrix[i][j] = 0;
+ }
+ for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
+ fendladdercarbonfiberjunction[i] = 0;
+ }
+ for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
+ fendladdercarbonfiberjunctionmatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
+ fendladdercarbonfibermatrix[i] = 0;
+ }
+ for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
+ fendladdermountingblockclipmatrix[i] = 0;
+ }
+ for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
+ fendladderlowersupptrans[i] = 0;
+ }
+ for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
+ fladdercablematrix[i] = 0;
+ }
+ for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
+ fladdersegment[i] = 0;
+ }
+ for (Int_t i = 0; i < fgkladdernumber; i++) {
+ fladder[i] = 0;
+ fladdermatrix[i] = 0;
+ fssdsensormatrix[i] = 0;
+ flayermatrix[i] = 0;
+ }
+ for (Int_t i = 0; i < 2; i++) {
+ fLay5LadderSupport[i] = 0;
+ fLay6LadderSupport[i] = 0;
+ fcoolingtubematrix[i] = NULL;
+ fendladdersegment[i] = NULL;
+ fendladdersegmentmatrix[i] = NULL;
+ }
}
-/////////////////////////////////////////////////////////////////////////////////
-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),
- fSSDRohaCellCone(s.fSSDRohaCellCone),
- fSSDAir(s.fSSDAir),
- fSSDCopper(s.fSSDCopper),
- 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),
- fSSDCone(s.fSSDCone),
- 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
- ////////////////////////
-}
-/////////////////////////////////////////////////////////////////////////////////
-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::CreateTransformationMatrices(){
///////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
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];
- }
- localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+ TGeoTranslation* localcoolingtubetrans[2];
+ TVector3* localcoolingtubevect[2];
+
+ localcoolingtubevect[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],
+ fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
+ - fgkCarbonFiberLowerSupportWidth
+ - fgkLowerSupportToSensorZ ,
- 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));
- }
+ localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[0]->Y(),
+ localcoolingtubevect[0]->Z());
+ for(Int_t j=0; j<2; j++){
+ localcoolingtubetrans[j] =
+ new TGeoTranslation(localcoolingtubevect[j]->X(),
+ localcoolingtubevect[j]->Y(),
+ localcoolingtubevect[j]->Z());
+ fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[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];
+ localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
+ localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
for(Int_t i=0; i<2; i++)
- for(Int_t j=0; j<(i==0?6:4); j++)
+ for(Int_t j=0; j<2; j++)
localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
+
+ Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
- fgkCoolingTubeSupportRmax)
+ fgkCarbonFiberJunctionLength,
- 0.5*(fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]),
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
- 0.5*fgkCoolingTubeSupportHeight);
localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
- fgkCoolingTubeSupportRmax)
- fgkCarbonFiberJunctionLength
+ fgkCarbonFiberTriangleLength,
- 0.5*(fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]),
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
- 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,
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
- 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*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
- 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++){
+ for(Int_t j=0; j<2; j++){
fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
}
/////////////////////////////////////////////////////////////
// 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]);
+ TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
+ - 0.5*fgkSSDCoolingBlockLength,
+ fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
+ fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
+ 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
+ fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
/////////////////////////////////////////////////////////////
// SSD Stiffener Flex Transformations
/////////////////////////////////////////////////////////////
TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
localendladdercarbonfiberjunctionmatrix[i]
- = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
+ = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
localendladdercarbonfiberjunctionrot[i]
- = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
+ = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
localendladdercarbonfiberjunctiontrans[i]
- = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
+ = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
fendladdercarbonfiberjunctionmatrix[i]
- = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
+ = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
}
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
- for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; 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++)
+ for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
*localendladdercarbonfiberjunctionglobalrot[i]);
}
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
- for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
localendladdercarbonfiberjunctionmatrix[i][j] =
new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
*localendladdercarbonfiberjunctionrot[i][j]);
new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
+ 0.5*fgkSSDMountingBlockWidth),
- 0.5*fgkCarbonFiberLowerSupportHeight);
+ fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
fgkCarbonFiberLowerSupportVolumePosition[1]
+ fgkCarbonFiberLowerSupportVolumePosition[0],
localladdercablerot[1]->SetAngles(90.,60.,-90.);
localladdercablerot[2]->SetRotation((*localladdercablerot[1])
* (*localladdercablerot[0]));
+ //TGeoRotation* localladdercablerot = new TGeoRotation();
+ //localladdercablerot->SetAngles(90.,0.,0.);
////////////////////////////////////////////
// LocalLadderCableCombiTransMatrix
////////////////////////////////////////////
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]);
+ for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
+ fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
+
///////////////////////////////////////////
// Setting Ladder HMatrix
///////////////////////////////////////////
- fgkLowerSupportToSensorZ,
0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
-fgkSSDModuleCoolingBlockToSensor);
+
for(Int_t i=0; i<2; i++)
localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
*localssdsensorrot);
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];
+ for(Int_t j=0; j<2; j++){
+ delete localcoolingtubevect[j];
+ delete localcoolingtubetrans[j];
}
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 localendlladdercoolingtuberot;
for(Int_t i=0; i<2; i++){
- for(Int_t j=0; j<(i==0?6:4); j++)
- delete localendlladdercoolingtubetrans[i][j];
+ for(Int_t j=0; j<2; j++)
+ delete localendlladdercoolingtubetrans[i][j];
delete [] localendlladdercoolingtubetrans[i];
}
}
delete localladdermotherrot;
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
- for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
+ for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
delete localendladdercarbonfiberjunctionmatrix[i][j];
delete localendladdercarbonfiberjunctionrot[i][j];
delete localendladdercarbonfiberjunctiontrans[i][j];
/////////////////////////////////////////////////////////////
// SSD Cooling Tube Support
/////////////////////////////////////////////////////////////
- Int_t edgesnumber = 16;
+ Int_t edgesnumber = 3;
fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
/////////////////////////////////////////////////////////////
// SSD Hybrid
/////////////////////////////////////////////////////////////
// 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);
+ CreateCoolingTubes();
/////////////////////////////////////////////////////////////
// SSD Flex
/////////////////////////////////////////////////////////////
0.5*fgkSSDSensorHeight,
0.5*ssdsensitivelength);
TGeoVolume* ssdsensorsensitiveLay5 =
- new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
+ new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
TGeoVolume* ssdsensorsensitiveLay6 =
- new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
+ new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
TGeoBBox* ssdsensorinsensitiveshape[2];
fgkCarbonFiberJunctionEdge[0]
* TMath::Sin(fgkCarbonFiberJunctionAngle[0]
* TMath::DegToRad()));
- vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
+ vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
fgkCarbonFiberJunctionEdge[1]);
- vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
+ vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance);
vertex[1] = GetReflection(vertex[5],reflectionparam);
vertex[2] = GetReflection(vertex[4],reflectionparam);
Double_t xvertexpoints[6], yvertexpoints[6];
}
///////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
- Double_t width, Double_t* thickness)const{
+ Double_t width, const Double_t* thickness)const{
/////////////////////////////////////////////////////////////
// Method generating the Sensor Support
/////////////////////////////////////////////////////////////
// Vertex Positioning for TGeoXTru
///////////////////////////////////////
TVector3** vertexposition = new TVector3*[kvertexnumber];
- vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
- fgkCoolingTubeSupportRmin*SinD(angle));
+
+ Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
+ vertexposition[0] = new TVector3(router*CosD(angle),
+ router*SinD(angle));
vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
fgkCoolingTubeSupportRmax*SinD(angle));
vertexposition[2] = 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)));
+ new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
+ router*SinD(psi+i*(2.*phi/nedges)));
///////////////////////////////////////////////////////////////////////
// TGeoXTru Volume definition for Cooling Tube Support Arc Part
///////////////////////////////////////////////////////////////////////
ymothervertex);
virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
- TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
- virtualCoolingTubeSupportShape,fSSDAir);
+ /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
+ virtualCoolingTubeSupportShape,fSSDAir); */
+ TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
+
////////////////////////////////////////
// Positioning Volumes in Virtual Volume
////////////////////////////////////////
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);
+ //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
+ //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
+ //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
+ //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
// Mother Volumes Containers
/////////////////////////////////////////////////////////////
const Int_t kmothernumber = 2;
- const Int_t kmothervertexnumber = 12;
+ const Int_t kmothervertexnumber = 8;
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];
- TGeoVolumeAssembly* ssdhybridmother[kmothernumber];
+
+ TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
+ TGeoVolume* ssdhybridmother[kmothernumber][2];
+
+ TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
+ TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
+ TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
+
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);
- ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
+ xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
+ xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
+ -fgkSSDChipCablesHeight[i+2];
+
+ xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
+ xmothervertex[i][3] = xmothervertex[i][2];
+ ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
+
+ xmothervertex[i][4] = xmothervertex[i][2]-0.4;
+ ymothervertex[i][4] = ymothervertex[i][3];
+ xmothervertex[i][5] = xmothervertex[i][4];
+ ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
+
+ xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
+ ymothervertex[i][6] = ymothervertex[i][5];
+
+ xmothervertex[i][7] = xmothervertex[i][6];
+ ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
+ TGeoXtru *shape = new TGeoXtru(2);
+ shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
+ shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
+ shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
+ ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
+ ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
+ ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
}
/////////////////////////////////////////////////////////////
// SSD Stiffener
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 knapacitor0603number = 5;
+ TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
+ 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
+ 0.5*fgkSSDCapacitor0603Width,
+ 0.5*fgkSSDCapacitor0603Height);
+ TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
+ fSSDAir);
+
TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
- 0.5*fgkSSDCapacitor0603Length,
- 0.5*(fgkSSDCapacitor0603Width),
- 0.5*fgkSSDCapacitor0603Height);
+ 0.5*fgkSSDCapacitor0603Length,
+ 0.5*fgkSSDCapacitor0603Width,
+ 0.5*fgkSSDCapacitor0603Height);
TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
fSSDStiffener0603CapacitorMedium);
capacitor0603->SetLineColor(fColorAl);
+ TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
+ capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
+
+ TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
+ 0.5*fgkSSDCapacitor0603CapLength,
+ 0.5*fgkSSDCapacitor0603Width,
+ 0.5*fgkSSDCapacitor0603Height);
+ TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
+ fSSDStiffenerCapacitorCapMedium);
+ capacitor0603cap->SetLineColor(fColorNiSn);
+ TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
+ capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
+ TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
+ capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
+
+
+ TGeoVolume* ssdchip = GetSSDChip();
+
+ const Int_t knedges = 5;
+ TGeoVolume *ssdchipcables[2];
+
for(Int_t i=0; i<kmothernumber; i++){
+ for(Int_t j=0; j<kssdstiffenernumber; j++){
+ ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
+ for(Int_t k=1; k<knapacitor0603number+1; k++){
+ ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
+ new TGeoCombiTrans("",
+ -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
+ -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
+ (k-3.)/6*fgkSSDStiffenerLength,
+ hybridmotherrotInv));
+ }
+ }
+
+ GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
+ for(Int_t k=0; k<fgkSSDChipNumber; k++){
+ TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
+ - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
+ - fgkSSDChipCablesHeight[i+2],
+ (k+0.5-fgkSSDChipNumber/2)*
+ (fgkSSDChipLength + fgkSSDChipSeparationLength));
+ TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
+ - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
+ (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
+ hybridmotherrotInv);
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]);
+ ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
+ ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
+ }
+ }
+ // Final placement by assembly
+ ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
+ ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
+ ssdhybridlist->Add(ssdhybridassembly[i]);
}
-/////////////////////////////////////////////////////////////
-// Mother Volume Containing Capacitor Part
-/////////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////////
+ // Mother Volume Containing Capacitor Part
+ /////////////////////////////////////////////////////////////
const Int_t kcapacitormothernumber = 8;
Double_t xcapacitorvertex[kcapacitormothernumber];
Double_t ycapacitorvertex[kcapacitormothernumber];
////////////////////////////
// Connector
///////////////////////////
- const Int_t kssdconnectornumber = 2;
- TGeoBBox* ssdconnectorshape[kssdconnectornumber];
+ const Int_t kssdconnectorlayernumber = 3;
+ TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
+ Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
+ /*
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++){
+ */
+ Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
+ const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
+ TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
+ TGeoVolume* ssdconnector[kssdconnectorlayernumber];
+ for(Int_t i=0; i<kssdconnectorlayernumber; i++){
+ ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
0.5*fgkSSDConnectorWidth,
- 0.5*((1-i)*fgkSSDConnectorAlHeight
- + i*fgkSSDConnectorNiHeight),
- i==0? ssdAlconnectororigin : ssdNiconnectororigin);
+ 0.5*ssdConnectorThickness[i],
+ ssdconnectororigin);
+ ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
- i==0 ? fSSDAlTraceFlexMedium
- : fSSDStiffenerConnectorMedium);
- ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
+ ssdConnectorMedium[i]);
+ ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
}
- TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
+ const Int_t kssdconnectornumber = 4;
+ TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
+ fgkSSDConnectorPosition[0]
- fgkSSDConnectorSeparation
-(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]);
+ for(Int_t i=0; i<kssdconnectornumber; i++) {
+ Int_t nlay = kssdconnectorlayernumber - 1;
+ if (i == 1 || i == 2)
+ nlay++;
+ for(Int_t j=0; j<nlay; 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)};
+// 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,
- ssdcapacitor1812origin);
+ 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);
+ - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
+
+ TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
+ 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
+ 0.5*fgkSSDCapacitor1812Height);
+ TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
+ fSSDStiffenerCapacitorCapMedium);
+ capacitor1812cap->SetLineColor(fColorNiSn);
+ TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
+ - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
+ 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
+ - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
+ 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
+ ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
+ TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
+ capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
+ 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
+ - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
+ 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
+ ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
+
////////////////////////////
//Hybrid Wire
////////////////////////////
0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
+ fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
ssdstiffenershape->GetDZ()
- + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
+ + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
new TGeoRotation("HybridWireRot1",0.,90.,0.));
hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
0.0,
/////////////////////////////////////////////////////////////
delete hybridwirecombitrans[0];
delete hybridwirecombitrans[1];
- delete ssdchipsystemlist;
return ssdhybridlist;
/////////////////////////////////////////////////////////////
}
localcoolingblockrot->SetAngles(0.,90.,0.);
TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
TVector3* coolingblocktransvector;
- coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
- + fgkSSDCoolingBlockLength,
+ coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
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 (*localcoolingtubetrans,*localcoolingtuberot);
- Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
for(Int_t i=0; i<kcoolingblocktransnumber; i++){
for(Int_t j=0; j<kcoolingblocktransnumber; j++){
- TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
+ TGeoTranslation localcoolingblocktrans(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);
}
}
- /////////////////////////////////////////////////////////////
- // 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 TGeoVolumeAssembly("CoolingBlockSystem");
-// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
-// coolingsystemothershape,fSSDAir);
- /////////////////////////////////////////////////////////////
- // SSD Cooling Tube Part
- /////////////////////////////////////////////////////////////
- TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
- coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
- coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
- 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]);
+ for(Int_t i=0; i<kcoolingblocknumber; i++){
+ coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
}
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
- delete coolingblocktransvector;
- delete localcoolingblockrot;
- delete localcoolingtubetrans;
- delete localcoolingtuberot;
- /////////////////////////////////////////////////////////////
- // Checking overlaps
- /////////////////////////////////////////////////////////////
- //coolingsystemother->CheckOverlaps(0.01);
- /////////////////////////////////////////////////////////////
- return coolingsystemother;
+ delete coolingblocktransvector;
+ delete localcoolingblockrot;
+
+ return coolingsystemother;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
ymothervertex[6] = ymothervertex[5];
xmothervertex[7] = xmothervertex[6];
- ymothervertex[7] = ymothervertex[4];
+ ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance;
xmothervertex[8] = xmothervertex[7]
+ 0.5*(fgkSSDMountingBlockLength[1]
- fgkSSDMountingBlockLength[2]);
- ymothervertex[8] = ymothervertex[4];
+ ymothervertex[8] = ymothervertex[7];
xmothervertex[9] = xmothervertex[8];
ymothervertex[9] = ymothervertex[2];
xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
return ssdmountingblockclip;
}
///////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
+void AliITSv11GeometrySSD::CreateCoolingTubes() {
/////////////////////////////////////////////////////////////
// Method generating the Cooling Tube
+ // sets fcoolingtube and returns list for endladdercoolingtube
/////////////////////////////////////////////////////////////
- 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)
- -0.5*fgkSSDTolerance);
- coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[0][0]->GetDz());
- coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDModuleStiffenerPosition[1]
- - fgkSSDSensorOverlap-fgkSSDTolerance));
- coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[1][0]->GetDz());
- coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDTolerance));
- coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance);
- // 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]-fgkSSDTolerance));
- 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-fgkSSDTolerance));
- endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
- endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
- - fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[1]
- - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
- endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance);
- 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-fgkSSDTolerance));
- endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[3][0]->GetDz()-0.5*fgkSSDTolerance);
- endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkendladdercoolingsupportdistance[2]-fgkSSDTolerance));
- endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[4][0]->GetDz()-0.5*fgkSSDTolerance);
- // 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);
- }
+ TGeoTube *coolingtubeshape[2];
+ // Ladder Cooling Tubes
+
+ // MvL: Simplified cooling tubes
+ coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
+ coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
+
+ // End Ladder Cooling Tubes
+ TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdercoolingtubeshape[i] = new TGeoTube*[2];
+
+ Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
+ endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
+ endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[0][0]->GetDz());
+ endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
+ endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
+ // Ladder Cooling Tubes
+ TGeoVolume* coolingtube[2];
+ coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
+ coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
+ coolingtube[0]->SetLineColor(fColorPhynox);
+ coolingtube[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);
+ 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);
+ TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
+ coolingtubeshape[0]->GetRmax(),
+ coolingtubeshape[0]->GetDz());
+ fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
+ fcoolingtube->AddNode(coolingtube[0],1);
+ fcoolingtube->AddNode(coolingtube[1],1);
+
// 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;
+ endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
+ endladdercoolingtubeshape[i][0]->GetRmax(),
+ endladdercoolingtubeshape[i][0]->GetDz());
+ fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
+ endladdervirtualcoolingtubeshape[0],
+ fSSDAir);
+ fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
+ endladdervirtualcoolingtubeshape[1],
+ fSSDAir);
+ fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
+ fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
+ fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
+ fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
}
///////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
return ssdcoolingblock;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
+void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
///////////////////////////////////////////////////////
- const Int_t kssdchipcablesnumber = 2;
- const Int_t kssdchipcableslaynumber = 2;
- const Int_t kvertexnumber = 4*(nedges+1)+4;
+ static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
+ static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
+ static const Int_t kvertexnumber = 4*(nedges+1)+4;
Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
Double_t ssdchipcablesradius[kssdchipcableslaynumber];
- ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
+ ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
- fgkSSDChipCablesHeight[0]
- fgkSSDChipCablesHeight[1]);
ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[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];
- }
+
+ Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
+ Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
+
TVector3* vertex = new TVector3();
TVector3* transvector[kssdchipcableslaynumber];
transvector[0] = new TVector3(fgkSSDChipWidth,
- SSDChipCablesHeigth-ssdchipcablesradius[0]);
+ SSDChipCablesHeight-ssdchipcablesradius[0]);
transvector[1] = new TVector3();
- TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
- TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
- const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
+ TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
+ TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
+ const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
{"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
"SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
for(Int_t k=0; k<kssdchipcablesnumber; k++){
+ fgkSSDChipCablesHeight[0]
+ fgkSSDChipCablesHeight[1]);
for(Int_t i=0; i<kssdchipcableslaynumber; i++){
- vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
+ vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
- fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
- vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
+ vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
- i*fgkSSDChipCablesHeight[0]);
vertexposition[i][2*(nedges+1)+2] =
new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
/////////////////////////////////////////////////////////////
// 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;
- new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
- TGeoVolumeAssembly* ssdchipcablesmother = new TGeoVolumeAssembly("SSDChipCablesMother");
-// 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);
+ static const Int_t kmothervertexnumber = 8;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ xmothervertex[0] = xvertexpoints[0][1];
+ ymothervertex[0] = yvertexpoints[0][1];
+ xmothervertex[1] = xvertexpoints[0][2+nedges/2];
+ ymothervertex[1] = yvertexpoints[0][1];
+ xmothervertex[2] = xvertexpoints[0][2+nedges/2];
+ ymothervertex[2] = yvertexpoints[0][2+nedges];
+ xmothervertex[3] = xvertexpoints[0][3+nedges];
+ ymothervertex[3] = yvertexpoints[0][3+nedges];
+ xmothervertex[4] = xvertexpoints[0][3+2*nedges];
+ ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
+ xmothervertex[5] = xvertexpoints[0][4+2*nedges];
+ ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
+ xmothervertex[6] = xvertexpoints[1][5+2*nedges];
+ ymothervertex[6] = yvertexpoints[1][5+2*nedges];
+ xmothervertex[7] = xvertexpoints[0][1];
+ ymothervertex[7] = yvertexpoints[1][5+2*nedges];
+ TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
+ ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
+ ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
+ ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
+
+ cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
+ cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
+
+ cableL->AddNode(ssdchipcable[0],1);
+ cableL->AddNode(ssdchipcable[1],1);
+ cableR->AddNode(ssdchipcable[2],1);
+ cableR->AddNode(ssdchipcable[3],1);
+
/////////////////////////////////////////////////////////////
// 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 knedges = 5;
- const Int_t kchipsystemnumber = 2;
-
- TGeoVolumeAssembly* chipsystemother[kchipsystemnumber];
- const char* chipsytemothername[kchipsystemnumber] =
- {"SSDChipSytemother1","SSDChipSytemother2"};
- for(Int_t i=0; i<kchipsystemnumber; i++){
- chipsystemother[i] = new TGeoVolumeAssembly(chipsytemothername[i]);
- }
- /////////////////////////////////////////////////////////////
- // 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{
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
/////////////////////////////////////////////////////////////
// SSD Chip Assembly Generation
/////////////////////////////////////////////////////////////
- const Int_t kssdchiprownumber = 2;
TGeoBBox* ssdchipcompshape[2];
ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
0.5*fgkSSDChipLength,
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);
- TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer");
- /////////////////////////////////////////////////////////////
- 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;
+ return ssdchip;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
// Method returning a List containing pointers to Ladder Cable Volumes
+ //
+ // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
+ // each contains 2 volumes, one for polyamide and one for aluminium
/////////////////////////////////////////////////////////////
const Int_t kladdercablesegmentnumber = 2;
/////////////////////////////////////////
new TGeoTranslation("LadderCableSegmentBBoxTrans1",
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
- 0.5*fgkSSDFlexHeight[0]),
+ 0.5*fgkSSDLadderCableHeight[0]),
new TGeoTranslation("LadderCableSegmentBBoxTrans2",
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
- fgkSSDFlexHeight[0]
- +0.5*fgkSSDFlexHeight[1])
+ fgkSSDLadderCableHeight[0]
+ +0.5*fgkSSDLadderCableHeight[1])
};
static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
static TGeoVolume* laddercablesegmentarbassembly =
new TGeoBBox(laddercablesegmentbboxshapename[i],
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
- 0.5*fgkSSDFlexHeight[i]);
+ 0.5*fgkSSDLadderCableHeight[i]);
for(Int_t i=0; i<kladdercablesegmentnumber; i++){
laddercablesegmentbbox[i] =
new TGeoBBox(ladderendcablesegmentbboxshapename[i],
0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
- 0.5*fgkSSDFlexHeight[i]);
+ 0.5*fgkSSDLadderCableHeight[i]);
const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
{"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
- 0.5*fgkSSDFlexHeight[0]);
+ 0.5*fgkSSDLadderCableHeight[0]);
ladderendcablesegmentbboxtrans[1] =
new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
0.5*ssdendladdercablelength,
0.5*fgkSSDLadderCableWidth,
- fgkSSDFlexHeight[0]
- +0.5*fgkSSDFlexHeight[1]);
+ fgkSSDLadderCableHeight[0]
+ +0.5*fgkSSDLadderCableHeight[1]);
TGeoVolume* ladderendcablesegmentbboxassembly =
new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
for(Int_t i=0; i<kladdercablesegmentnumber; i++)
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
- // Method generating Ladder Cable Volumes Assemblies
+ // Method generating Ladder Cable of given length (n modules + end)
+ // Called by GetLadderCableAssembly
/////////////////////////////////////////////////////////////
TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
TGeoTranslation* laddercabletrans = new TGeoTranslation(
i*(fgkCarbonFiberJunctionWidth),
fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
- i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
+ i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
- if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
+ if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
+
}
TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
- fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
- (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
+ fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
+ (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
return laddercable;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
- /////////////////////////////////////////////////////////////
- // Method generating Ladder Cable Volumes Assembly
- /////////////////////////////////////////////////////////////
- TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
+ ///////////////////////////////////////////////////////////////////
+ // Main method generating Ladder Cable bundles containing n cables
+ ///////////////////////////////////////////////////////////////////
+ Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
+ Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
+ TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
+ TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
char laddercabletransname[100];
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.));
+ snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
+ laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
+ new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
}
- return laddercableassembly;
+ return laddercable;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
// Method generating Ladder Cable List Assemblies
+ // containing two cables bundles, i.e. P+N readout for one endcap
/////////////////////////////////////////////////////////////
- const Int_t kladdercableassemblynumber = 2;
+ const Int_t kladdercableassemblynumber = 2;
TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
TGeoVolume* ladderCable[kladdercableassemblynumber];
char laddercableassemblyname[100];
TList* laddercableassemblylist = new TList();
for(Int_t i=0; i<kladdercableassemblynumber; i++){
- sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
+ snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
new TGeoCombiTrans((n-1)
/////////////////////////////////////////////////////////////
fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
+
+ /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
+ TGeoXtru *laddersegmentshape = new TGeoXtru(2);
+ static const Int_t ntrianglevtx = 3;
+ Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
+ Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+ laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
+ laddersegmentshape->DefineSection(0,0);
+ laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
+ fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
+ fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
+ */
+
if(!fCreateMaterials) CreateMaterials();
if(!fTransformationMatrices) CreateTransformationMatrices();
if(!fBasicObjects) CreateBasicObjects();
fcarbonfibersupportmatrix[j]);
}
// Placing Carbon Fiber Junction
- for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
+ 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++)
+ 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] :
+ fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
fssdsensorsupport[1][i],
j+1,fssdsensorsupportmatrix[j]);
// Placing SSD Cooling Tube Support
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]);
- }
+ fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
+ fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
// Placing SSD Hybrid
switch(i){
case 0:
break;
}
// Placing Cooling Block System
- fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
+ 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]);
- }
+ for(Int_t j=0; j<fgkflexnumber; j++){
+ fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
+ fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
+ }
}
}
///////////////////////////////////////////////////////////////////////////////
if(!fTransformationMatrices) CreateTransformationMatrices();
if(!fBasicObjects) CreateBasicObjects();
for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
- for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
+ for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
fendladdersegment[i]->AddNode(j==2 ?
fendladdercarbonfiberjunction[i][1] :
fendladdercarbonfiberjunction[i][0],
/////////////////////////////////////////////////////////////
// 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]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
}
///////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetLadder(){
// Setting the vertices
///////////////////////
Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
- * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
+ * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[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;
+ ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
- laddercablethickness/SinD(2.*fgkSSDFlexAngle);
ymothervertex[0][2] = ymothervertex[0][1];
- fgkSSDModuleStiffenerPosition[1]
- fgkSSDStiffenerWidth)
+ fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
+
TList* laddercableassemblylist[4];
const Int_t kendladdercablesnumber = 4;
+ TGeoRotation *laddercablerot = new TGeoRotation();
+ laddercablerot->SetAngles(90.,60.,-90.);
for(Int_t i=0; i<fgkladdercablesnumber; i++)
for(Int_t j=0; j<kendladdercablesnumber; j++){
laddercableassemblylist[j] =
char sideladdersupportpiecename[100];
char centerladdersupportpiecename[100];
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);
+ snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
+ snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
+ snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
+ snprintf(centerladdersupportpiecename,100,"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]
// Mounting Block Down Vertex
///////////////////////////
mountingblockpiecedownshape[i] = new TGeoXtru(2);
- sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
+ snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
+ fgkMountingBlockSupportDownHeight
// Mounting Block Up Vertex
///////////////////////////
mountingblockpieceupshape[i] = new TGeoXtru(2);
- sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
+ snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
+ fgkMountingBlockSupportUpHeight[i]
mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
-fgkMountingBlockSupportWidth[0]);
mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
- sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
+ snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
mountingblocksupportrapezoidown[i]->SetLineColor(9);
mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
-fgkMountingBlockSupportWidth[0]);
mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
- sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
+ snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
mountingblocksupportrapezoidup[i]->SetLineColor(9);
xmothervertex[i][7] = xmothervertex[i][6];
ymothervertex[i][7] = ymothervertex[i][0];
- sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
- sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
+ snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
+ snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
downmotherladdersupportshape[i] = new TGeoXtru(2);
downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
// 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],
- fSSDCarbonFiberMedium);
- mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
- mountingblocksupportboxupshape[i][j],
- fSSDCarbonFiberMedium);
+ snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
+ snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
+ mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
+ mountingblocksupportboxdownshape[i][j],
+ fSSDCarbonFiberMedium);
+ mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
+ mountingblocksupportboxupshape[i][j],
+ fSSDCarbonFiberMedium);
mountingblocksupportboxdown[i][j]->SetLineColor(9);
mountingblocksupportboxup[i][j]->SetLineColor(9);
for(Int_t k=0; k<2; k++){
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));
+ new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
+ (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
}
}
Double_t **xmothervertex = new Double_t*[fgklayernumber];
for(Int_t i=0; i<fgklayernumber; i++){
lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
* TMath::Cos(theta[i]);
- lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeigth;
+ lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
}
for(Int_t i=0; i<fgklayernumber; i++){
/////////////////////////// Modified Version ?///////////////////
for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
lowerladderpconezsection[j],lowerladderpconradiusmin[i],
lowerladderpconradiusmax[i]);
- sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
+ snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
lowerladderpconsupport[i]->SetLineColor(fColorAl);
(i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
mothercoverplate->AddNode(holecontour[1],1);
mothercoverplate->AddNode(contour,1);
+
+ for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
+ delete [] endcapcoverplatesmallholetrans[i];
+ delete [] endcapcoverplatesmallholetrans;
/////////////////////////////////
return mothercoverplate;
}
char endcapcoolingwatertubetorusname[100];
char endcapcoolingwatertubename[100];
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]);
+ snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
+ snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
+ snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
+ snprintf(endcapcoolingwatertubename,100,"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]);
}
- 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);
endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
+i*(kendcapcoverholenumber[1]-1)+j]);
}
- return endcapsidecovermother;
+ delete [] endcapsidecoverboxtrans;
+ return endcapsidecovermother;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
char upendcapsupportname[100];
for(Int_t i=0; i<klayernumber; i++){
upendcapsupportshape[i] = new TGeoXtru(2);
- sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
+ snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
upendcapsupportshape[i]->DefineSection(0,0.);
upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
char downendcapsupportname[100];
for(Int_t i=0; i<klayernumber; i++){
downendcapsupportshape[i] = new TGeoXtru(2);
- sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
+ snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
downendcapsupportshape[i] = new TGeoXtru(2);
downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
if(i==0){
char endcapsupportmothername[100];
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);
+ snprintf(endcapsupportmothername,100,"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]);
char endcapsupportsystemothername[100];
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);
+ snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
- fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
(*radiusmax[i]*CosD(0.5*upedgeangle[i])
Double_t ssdcablepatchpanel3BB26radiusmin[2];
Double_t ssdcablepatchpanel3BB26radiusmax[2];
Double_t ssdcablepatchpanel3RB26zsection[2];
- ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth+2.8;
+ ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8+0.003;//Avoid small overlap with SPDshieldring;
ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
+ 0.*fgkSSDCablesLay5RightSideHeight
- + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
+ fgkSSDCentralAL3SupportLength
+ fgkSSDPConeZLength[0];
TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
ssdcablepatchpanel3RB26pconshape,fSSDCopper);
ssdcablepatchpanel3RB26pcon->SetLineColor(9);
- TGeoRotation* ssdcablepatchpanel3B26rot[3];
+ TGeoRotation* ssdcablepatchpanel3B26rot[4];
for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
+ fgkSSDCentralAL3SupportLength
+ (4.0/5.0)*fgkSSDPConeZLength[0];
ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
- ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
+ ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
TGeoPcon* ssdcableitsring3BB26pconshape[4];
ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
+ 0.*fgkSSDCablesLay5RightSideHeight
+ 0.*fgkSSDCablesLay6RightSideHeight
- + 0.5*fgkSSDPatchPanelHeigth;
+ + 0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
- fgkSSDCentralAL3SupportLength
- fgkSSDPConeZLength[0];
ssdcablepatchpanel3RB24pconshape,
fSSDCopper);
ssdcablepatchpanel3RB24pcon->SetLineColor(9);
- TGeoRotation* ssdcablepatchpanel3B24rot[3];
+ TGeoRotation* ssdcablepatchpanel3B24rot[4];
for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
Double_t ssdcableitsring3BB24pconrmax[2];
ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
- ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
+ ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
TGeoPcon* ssdcableitsring3BB24pconshape[4];
return ssdcablesmother;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
+TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
Double_t height, const char* shapename, Int_t isign) const{
/////////////////////////////////////////////////////////////
// Method generating an Arb shape
return arcshape;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
+TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
///////////////////////////////////////////////////////////////////////
// Method Generating the Screw Shape
// radius[0]: outer radius
return screwshape;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
+TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
///////////////////////////////////////////////////////////////////////
// Method Generating the Hole Shape
// radius of the Hole
return holeshape;
}
////////////////////////////////////////////////////////////////////////////////
-TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
+TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
/////////////////////////////////////////////////////////////
// Given an axis specified by param, it gives the reflection of the point
// respect to the axis
return reflectedvector;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
+TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
Double_t dx,
Double_t dy,
Double_t dz) const{
// Method returning the Medium type
/////////////////////////////////////////////////////////////
char ch[100];
- sprintf(ch, "ITS_%s",mediumName);
+ snprintf(ch,100, "ITS_%s",mediumName);
TGeoMedium* medium = gGeoManager->GetMedium(ch);
if (! medium)
AliError(Form("medium %s not found !\n", mediumName));
////////////////////////////////
fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
+ fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
///////////////////////////
// Stiffener Hybrid Wire
///////////////////////////
/////////////////////////////////////////////////////////////////////
fSSDAir = GetMedium("SDD AIR$");
fSSDCopper = GetMedium("COPPER$");
+ fSSDSn = GetMedium("Sn$");
fCreateMaterials = kTRUE;
}
/////////////////////////////////////////////////////////////////////
+