X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySSD.cxx;h=62486d399fa8bb664aa2b308681420b2e7091205;hb=5066aa9a753b18f28af39cb8b7da418c8ab6e8ff;hp=f21120681775da10632774eeece3bbaa544f492c;hpb=47f8de53ccc9269815cb972bb6afdcfedd0ad3da;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx index f2112068177..62486d399fa 100644 --- a/ITS/AliITSv11GeometrySSD.cxx +++ b/ITS/AliITSv11GeometrySSD.cxx @@ -29,6 +29,7 @@ #include "TList.h" #include "TGeoMatrix.h" #include "TGeoCompositeShape.h" +#include "TGeoBoolNode.h" #include "TGeoTube.h" #include "TGeoBBox.h" #include "TGeoXtru.h" @@ -37,6 +38,7 @@ #include "TGeoPcon.h" #include "TRotation.h" #include "AliITSv11GeometrySSD.h" +#include "Riostream.h" ///////////////////////////////////////////////////////////////////////////////// // Names of the Sensitive Volumes of Layer 5 and Layer 6 ///////////////////////////////////////////////////////////////////////////////// @@ -47,7 +49,11 @@ const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6"; ///////////////////////////////////////////////////////////////////////////////// // Variable for Vertical Disalignement of Modules ///////////////////////////////////////////////////////////////////////////////// +const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm; +// For ladders: +const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Layer5 (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// @@ -171,7 +177,10 @@ const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength = const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth = 2.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] = - { 4.620*fgkmm, 5.180*fgkmm}; + { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment, + 5.220*fgkmm-fgkSSDModuleVerticalDisalignment}; +//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] = +// { 4.520*fgkmm, 5.130*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = { 0.450*fgkmm, 0.450*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition @@ -201,10 +210,12 @@ const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] = { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor - (fgkSSDSensorSideSupportHeight[1] - fgkSSDSensorSideSupportHeight[0]) + - fgkSSDModuleVerticalDisalignment - fgkSSDCoolingBlockHoleCenter - fgkSSDStiffenerHeight - fgkSSDChipHeight-fgkSSDSensorHeight, fgkSSDModuleCoolingBlockToSensor + - fgkSSDModuleVerticalDisalignment - fgkSSDCoolingBlockHoleCenter - fgkSSDStiffenerHeight - fgkSSDChipHeight-fgkSSDSensorHeight}; @@ -250,6 +261,7 @@ const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength ///////////////////////////////////////////////////////////////////////////////// // Carbon Fiber Lower Support Parameters (lengths are in mm) ///////////////////////////////////////////////////////////////////////////////// +const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth = 0.950*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght @@ -335,7 +347,7 @@ const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius = 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.}; @@ -356,27 +368,23 @@ const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDL - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportDownHeight, fgkSSDLay6RadiusMin - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportDownHeight}; const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportRadius[0], fgkSSDLay6RadiusMax - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - 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; ///////////////////////////////////////////////////////////////////////////////// @@ -430,7 +438,7 @@ const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] = {62.0*fgkmm,21.87*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] = - {47.1*fgkmm,0.35*fgkmm}; + {47.0*fgkmm,0.35*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness = 1.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm; @@ -494,21 +502,21 @@ const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fg ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0; -const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {176.5*fgkmm,161.5*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 460.*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0; const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 176.5*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm; @@ -529,7 +537,7 @@ const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fg 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; @@ -573,6 +581,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fcoolingblocksystematrix(), fssdstiffenerflex(), fssdendflex(), + fcoolingtube(0), fendladdercoolingtubesupportmatrix(), fendladdermountingblock(), fendladdermountingblockclip(), @@ -639,6 +648,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s): fcoolingblocksystematrix(s.fcoolingblocksystematrix), fssdstiffenerflex(s.fssdstiffenerflex), fssdendflex(s.fssdendflex), + fcoolingtube(s.fcoolingtube), fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix), fendladdermountingblock(s.fendladdermountingblock), fendladdermountingblockclip(s.fendladdermountingblockclip), @@ -984,77 +994,24 @@ 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), + fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ , - 0.5*fgkCoolingTubeSupportHeight); - localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[2][0]->Y(), - localcoolingtubevect[2][0]->Z()); - localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation - - fgkCarbonFiberTriangleLength), - - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth - + fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0]) - + fgkSSDSensorLength - - 0.5*fgkSSDModuleStiffenerPosition[1], - - 0.5*fgkCoolingTubeSupportHeight); - localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[3][0]->Y(), - - 0.5*fgkCoolingTubeSupportHeight); - for(Int_t i=0; i<4; i++) + localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength, + localcoolingtubevect[0]->Y(), + localcoolingtubevect[0]->Z()); 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]) + localcoolingtubetrans[j] = + new TGeoTranslation(localcoolingtubevect[j]->X(), + localcoolingtubevect[j]->Y(), + localcoolingtubevect[j]->Z()); + fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j]) * (*localcoolingtuberot)); } ///////////////////////////////////////////////////////////// @@ -1063,110 +1020,38 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ 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]); } @@ -1189,7 +1074,8 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength - fgkSSDSensorCenterSupportThickness[0]), - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight - - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight)); + - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight + - fgkSSDModuleVerticalDisalignment)); fhybridmatrix = new TGeoHMatrix(); for(Int_t i=0; iMultiplyLeft(localhybridtrans[i]); ///////////////////////////////////////////////////////////// @@ -1253,7 +1139,8 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle * TMath::DegToRad()*ssdflexradiusmax - fgkSSDFlexLength[2]-TMath::Pi() - * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0] + - 0.1*fgkSSDFlexFullLength; Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle) + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle) + fgkSSDFlexLength[2]; @@ -1435,6 +1322,8 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ localladdercablerot[1]->SetAngles(90.,60.,-90.); localladdercablerot[2]->SetRotation((*localladdercablerot[1]) * (*localladdercablerot[0])); + //TGeoRotation* localladdercablerot = new TGeoRotation(); + //localladdercablerot->SetAngles(90.,0.,0.); //////////////////////////////////////////// // LocalLadderCableCombiTransMatrix //////////////////////////////////////////// @@ -1562,23 +1451,20 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ TGeoTranslation* localssdsensortrans[2]; for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation(); localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, - - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + fgkCarbonFiberJunctionWidth + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ, 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight - - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment + - fgkSSDModuleCoolingBlockToSensor + (fgkSSDSensorSideSupportHeight[1] - fgkSSDSensorSideSupportHeight[0])); localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, - - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + fgkCarbonFiberJunctionWidth + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ, 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight - -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment); + -fgkSSDModuleCoolingBlockToSensor); + for(Int_t i=0; i<2; i++) localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i], *localssdsensorrot); @@ -1711,13 +1597,9 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ 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; iAt(i); - for(Int_t i=0; iAt(fgkcoolingtubenumber+i); + CreateCoolingTubes(); ///////////////////////////////////////////////////////////// // SSD Flex ///////////////////////////////////////////////////////////// @@ -1881,9 +1758,9 @@ void AliITSv11GeometrySSD::CreateBasicObjects(){ new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber]; for(Int_t i=0; iX(), - (GetReflection(vertexposition[0][j],param))->Y()); - char* carbonfibersupportshapename[kshapesnumber] = + new TVector3((GetReflection(vertexposition[0][j],param))->X(), + (GetReflection(vertexposition[0][j],param))->Y()); + const char* carbonfibersupportshapename[kshapesnumber] = {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"}; - char* carbonfibersupportname[kshapesnumber] = + const char* carbonfibersupportname[kshapesnumber] = {"CarbonFiberSupport1","CarbonFiberSupport2"}; TGeoArb8* carbonfibersupportshape[kshapesnumber]; TGeoVolume* carbonfibersupport[kshapesnumber]; @@ -2054,8 +1931,8 @@ TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){ ///////////////////////////////////////////////////////////// const Int_t kvertexnumber = 6; TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2); - Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0] - * TMath::DegToRad()),-1.,0.}; + Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0] + * TMath::DegToRad()),-1.,0.,0.}; TVector3* vertex[kvertexnumber]; vertex[0] = new TVector3(); vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0] @@ -2116,9 +1993,9 @@ TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){ vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]); vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength, fgkCarbonFiberLowerSupportVolumePosition[1]); - char* carbonfiberlowersupportshapename[kshapesnumber] = + const char* carbonfiberlowersupportshapename[kshapesnumber] = {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"}; - char* carbonfiberlowersupportname[kshapesnumber] = + const char* carbonfiberlowersupportname[kshapesnumber] = {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"}; TGeoArb8* carbonfiberlowersupportshape[kshapesnumber]; TGeoVolume* carbonfiberlowersupport[kshapesnumber]; @@ -2191,8 +2068,10 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ // 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(), @@ -2201,10 +2080,11 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ fgkCoolingTubeSupportRmax); vertexposition[4] = new TVector3(-vertexposition[1]->X(), vertexposition[1]->Y()); + for(Int_t i=0; iDefineSection(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 //////////////////////////////////////// @@ -2331,18 +2213,18 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ 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 ///////////////////////////////////////////////////////////// delete [] vertexposition; - delete xvertexpoints; - delete yvertexpoints; - delete xvert; - delete yvert; + delete [] xvertexpoints; + delete [] yvertexpoints; + delete [] xvert; + delete [] yvert; for(Int_t i=0; i< kvirtualvertexnumber; i++) delete virtualvertex[i]; ///////////////////////////////////////////////////////////// @@ -2367,109 +2249,118 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ // 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; iDefinePolygon(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); + 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]; + + 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]; + + 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; + /* + for (Int_t j = 0; j<8; j++) { + cout << "vtx " << j << " " << xmothervertex[i][j] << " " << ymothervertex[i][j] << endl; + } + */ + 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 ///////////////////////////////////////////////////////////// TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape", 0.5*fgkSSDStiffenerLength, - 0.5*fgkSSDStiffenerWidth, + 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance), 0.5*fgkSSDStiffenerHeight); TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape, fSSDStiffenerMedium); ssdstiffener->SetLineColor(fColorStiffener); - TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber]; - for(Int_t i=0; iSetLineColor(fColorAl); + + TGeoVolume* ssdchip = GetSSDChip(); + + const Int_t knedges = 5; + TGeoVolume *ssdchipcables[2]; + for(Int_t i=0; iAddNode(ssdstiffener,1,hybridmotherrotInv); + for(Int_t k=1; kAddNode(capacitor0603,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; kAddNode(ssdstiffener,j+1,ssdstiffenertrans[j]); - for(Int_t k=1; kAddNode(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]; @@ -2497,8 +2388,9 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ ycapacitorvertex); ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight); ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height); - TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape, - fSSDAir); +// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape, +// fSSDAir); + TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother"); //////////////////////////// // Connector /////////////////////////// @@ -2575,8 +2467,8 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ - fgkSSDConnectorSeparation; Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth; - Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.) - + TMath::Power(wirey,2)); + Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey); + Double_t wireangle = TMath::ATan(wirex/wirey); TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0., fgkSSDWireRadius, 0.5*ssdwireradius); @@ -2608,7 +2500,6 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ ///////////////////////////////////////////////////////////// delete hybridwirecombitrans[0]; delete hybridwirecombitrans[1]; - delete ssdchipsystemlist; return ssdhybridlist; ///////////////////////////////////////////////////////////// } @@ -2693,45 +2584,21 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){ + fgkCoolingTubeRmax)); coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter + fgkCoolingTubeRmax)); - TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem", - coolingsystemothershape,fSSDAir); - ///////////////////////////////////////////////////////////// - // SSD Cooling Tube Part - ///////////////////////////////////////////////////////////// - TGeoTube* coolingtubeshape[fgkcoolingtubenumber]; - coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.5*fgkSSDCoolingBlockWidth); - coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - 0.5*fgkSSDCoolingBlockWidth); - TGeoVolume* coolingtube[fgkcoolingtubenumber]; - coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0], - fSSDCoolingTubePhynox); - coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1], - fSSDCoolingTubeWater); - coolingtube[0]->SetLineColor(fColorPhynox); - coolingtube[1]->SetLineColor(fColorWater); + TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem"); TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30); ///////////////////////////////////////////////////////////// // Adding Cooling block to mother volume ///////////////////////////////////////////////////////////// - for(Int_t i=0; iAddNode(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; iAddNode(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{ @@ -2812,8 +2679,9 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{ ymothervertex); ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]); ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]); - TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape, - fSSDAir); + TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother"); +// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape, +// fSSDAir); ///////////////////////////////////////////////////////////// // SSDFlex Layer Shapes ///////////////////////////////////////////////////////////// @@ -2842,7 +2710,6 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{ + fgkSSDFlexHeight[1])); ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]); } - //ssdflexmother->CheckOverlaps(0.01); return ssdflexmother; } ///////////////////////////////////////////////////////////////////////////////// @@ -2855,7 +2722,8 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle * TMath::DegToRad()*ssdflexradiusmax - fgkSSDFlexLength[2]-TMath::Pi() - * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0] + - 0.1*fgkSSDFlexFullLength; const Int_t knedges = 20; const Int_t karcnumber = 2; TVector3* vertexposition[karcnumber*(knedges+1)]; @@ -2958,8 +2826,9 @@ for(Int_t i=0; iDefineSection(0,-0.5*fgkSSDFlexWidth[0]); ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]); - TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother", - ssdendflexmothershape,fSSDAir); +// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother", +// ssdendflexmothershape,fSSDAir); + TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother"); ////////////////////////////////////// // End Flex TGeoXtru Layer Definition ////////////////////////////////////// @@ -3021,8 +2890,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ - fgkSSDMountingBlockScrewHoleRadius[0]; xvertex[7] = xvertex[6]; yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor - + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0] - - fgkSSDModuleVerticalDisalignment; + + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]; yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0]; yvertex[2] = yvertex[1]; yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1]; @@ -3031,6 +2899,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ - fgkSSDMountingBlockHeight[0]; yvertex[6] = yvertex[5]; yvertex[7] = yvertex[0]; + /////////////////////////////////////////////////////////////////////// // TGeoXTru Volume definition for Mounting Block Part /////////////////////////////////////////////////////////////////////// @@ -3209,8 +3078,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]); xmothervertex[9] = xmothervertex[8]; ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor - + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0] - - fgkSSDModuleVerticalDisalignment; + + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]; ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness; ymothervertex[2] = ymothervertex[1]; ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1] @@ -3222,6 +3090,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness; ymothervertex[8] = ymothervertex[7]; ymothervertex[9] = ymothervertex[0]; + /////////////////////////////////////////////////////////////////////// // TGeoXTru Volume definition for Mounting Block Clip Part /////////////////////////////////////////////////////////////////////// @@ -3285,7 +3154,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ Int_t edgesnumber[2] = {50,6}; Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]), +0.5*(ymothervertex[3]-ymothervertex[2])}; - TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section); + TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section); TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl); clipscrew->SetLineColor(12); TGeoRotation* screwrot = new TGeoRotation(); @@ -3311,183 +3180,87 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ 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; iGetDz()); - coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.5*(fgkSSDModuleStiffenerPosition[1] - - fgkSSDSensorOverlap)); - coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - coolingtubeshape[1][0]->GetDz()); - coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.5*fgkSSDModuleStiffenerPosition[1]); - coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - coolingtubeshape[2][0]->GetDz()); - // End Ladder Cooling Tubes - TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber]; - for(Int_t i=0; iGetDz()); - endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkendladdercoolingsupportdistance[0] - + fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth)); - endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[1][0]->GetDz()); - endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0] - - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth)); - endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[2][0]->GetDz()); - endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkMountingBlockToSensorSupport - - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth) - - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1] - + fgkSSDSensorOverlap - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkEndLadderMountingBlockPosition[1] - - fgkCoolingTubeSupportWidth)); - endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[3][0]->GetDz()); - endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * fgkendladdercoolingsupportdistance[2]); - endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[4][0]->GetDz()); - // Ladder Cooling Tubes - TGeoVolume** coolingtube[fgkcoolingtubenumber]; - for(Int_t i=0; iSetLineColor(fColorPhynox); - coolingtube[i][1]->SetLineColor(fColorWater); - } - // End Ladder Cooling Tubes - TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber]; - for(Int_t i=0; iSetLineColor(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; iGetDz()); + 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; iSetLineColor(fColorPhynox); + endladdercoolingtube[i][1]->SetLineColor(fColorWater); + } + ///////////////////////////////////////////////////////////// // Virtual Volume containing Cooling Tubes ///////////////////////////////////////////////////////////// // Ladder Cooling Tubes - TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber]; - for(Int_t i=0; iGetRmin(), - 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; iGetRmin(), - 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; iAddNode(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){ @@ -3557,20 +3330,20 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){ // Deallocating memory ///////////////////////////////////////////////////////////// delete [] vertexposition; - delete xvertexpoints; - delete yvertexpoints; + delete [] xvertexpoints; + delete [] yvertexpoints; ///////////////////////////////////////////////////////////// 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]; @@ -3611,11 +3384,11 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, 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; kAddNode(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]; + xmothervertex[5] = xvertexpoints[0][4+2*nedges]; + ymothervertex[5] = yvertexpoints[0][4+2*nedges]; + 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 ///////////////////////////////////////////////////////////// @@ -3717,138 +3494,13 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, for(Int_t i=0; iDefinePolygon(kmothervertexnumber, - xmothervertex[i],ymothervertex[i]); - chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2] - -0.5*fgkSSDChipHeight); - chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight); - chipsystemother[i] = new TGeoVolume(chipsytemothername[i], - chipsystemothershape[i],fSSDAir); - } - ///////////////////////////////////////////////////////////// - // SSD Chip Cables - ///////////////////////////////////////////////////////////// - TGeoVolume* ssdchipcables[kchipsystemnumber]; - TGeoRotation** ssdchipcablesrot[kchipsystemnumber]; - TGeoTranslation** ssdchipcablestrans[kchipsystemnumber]; - TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber]; - ////////////////// - for(Int_t i=0; iSetAngles(-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; iAddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]); - Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength, - fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1] - - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist - - 0.5*fgkSSDChipWidth)}; - ///////////////////////////////////////////////////////////// - // Virtual Volume containing SSDChipAssembly - ///////////////////////////////////////////////////////////// - TGeoXtru* ssdchipmothershape = new TGeoXtru(2); - const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber; - Double_t xmothervertex[kssdmothervertexnumber]; - Double_t ymothervertex[kssdmothervertexnumber]; - /////////////////////// - // Setting the vertices - /////////////////////// - xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth; - xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1] - - ymothervertex[0]; - xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0]; - ymothervertex[2] = ymothervertex[1]; - xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0]; - xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0]; - ymothervertex[4] = ymothervertex[0]; - xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4]; - xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0] - + (0.5*fgkSSDChipLength-fgkSSDChipWidth); - ymothervertex[6] = ymothervertex[5]; - xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2] - - fgkSSDChipWidth; - xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth; - ymothervertex[8] = ymothervertex[7]; - xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth; - ymothervertex[9] = ymothervertex[6]; - xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9]; - xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0]; - ////////////////////////////////////////////////////////// - ssdchipmothershape->DefinePolygon(kssdmothervertexnumber, - xmothervertex,ymothervertex); - ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight); - ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight); - TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer", - ssdchipmothershape,fSSDAir); - ///////////////////////////////////////////////////////////// - for(Int_t i=0; iAddNode(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; ///////////////////////////////////////// // LadderSegmentBBox Volume ///////////////////////////////////////// - TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber]; + static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0}; const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] = {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"}; + + + const char* laddercablesegmentbboxname[kladdercablesegmentnumber] = + {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"}; + static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber]; + + static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = { + new TGeoTranslation("LadderCableSegmentBBoxTrans1", + 0.5*fgkSSDFlexWidth[0], + 0.5*fgkSSDLadderCableWidth, + 0.5*fgkSSDFlexHeight[0]), + new TGeoTranslation("LadderCableSegmentBBoxTrans2", + 0.5*fgkSSDFlexWidth[0], + 0.5*fgkSSDLadderCableWidth, + fgkSSDFlexHeight[0] + +0.5*fgkSSDFlexHeight[1]) + }; + static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ; + static TGeoVolume* laddercablesegmentarbassembly = + new TGeoVolumeAssembly("LadderCableSegmentArbAssembly"); + + static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber]; + static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber]; + + if (laddercablesegmentbboxshape[0] == 0) { + // Initialise static shapes and volumes for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : fColorPolyhamide); } - TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber]; - laddercablesegmentbboxtrans[0] = - new TGeoTranslation("LadderCableSegmentBBoxTrans1", - 0.5*fgkSSDFlexWidth[0], - 0.5*fgkSSDLadderCableWidth, - 0.5*fgkSSDFlexHeight[0]); - laddercablesegmentbboxtrans[1] = - new TGeoTranslation("LadderCableSegmentBBoxTrans2", - 0.5*fgkSSDFlexWidth[0], - 0.5*fgkSSDLadderCableWidth, - fgkSSDFlexHeight[0] - +0.5*fgkSSDFlexHeight[1]); - TGeoVolume* laddercablesegmentbboxassembly = - new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly"); + for(Int_t i=0; iAddNode(laddercablesegmentbbox[i],1, laddercablesegmentbboxtrans[i]); @@ -3991,9 +3611,9 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen } Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]}, {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}}; - char* laddercablesegmentarbshapename[kladdercablesegmentnumber] = + const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] = {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"}; - TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber]; + for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] = GetArbShape(laddercablesegmentvertexposition[i], laddercablesegmentwidth[i], @@ -4001,7 +3621,7 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen laddercablesegmentarbshapename[i]); const char* laddercablesegmentarbname[kladdercablesegmentnumber] = {"LadderCableSegmentArb1","LadderCableSegmentArb2"}; - TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber]; + for(Int_t i=0; iAddNode(laddercablesegmentarb[i],1, laddercablesegmentarbcombitrans); + } // End of static initialisations ///////////////////////////////////////// // End Ladder Cable Volume +// Note: this part depends explicitly on the length passed as an argument to the function ///////////////////////////////////////// TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber]; const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] = @@ -4073,11 +3693,13 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen laddercablesegmentlist->Add(laddercablesegmentarbassembly); laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly); return laddercablesegmentlist; - } +} + ///////////////////////////////////////////////////////////////////////////////// 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"); @@ -4087,38 +3709,43 @@ TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladderc fgkSSDLadderCableWidth-fgkSSDFlexWidth[0], i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])); laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans); - if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); + 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)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[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"); - char laddercabletransname[30]; + /////////////////////////////////////////////////////////////////// + // 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*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])}; + TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]),cableOrig); + TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir); + char laddercabletransname[100]; for(Int_t i=0; iAddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, - new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.)); + 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[30]; + char laddercableassemblyname[100]; TList* laddercableassemblylist = new TList(); for(Int_t i=0; iDefinePolygon(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(); @@ -4151,16 +3791,18 @@ void AliITSv11GeometrySSD::SetLadderSegment(){ fcarbonfibersupportmatrix[j]); } // Placing Carbon Fiber Junction - for(Int_t j=0; jAddNode(fcarbonfiberjunction,j+1, fcarbonfiberjunctionmatrix[j]); + } // Placing Carbon Fiber Lower Support - for(Int_t j=0; jAddNode(fcarbonfiberlowersupport[j],j+1, fcarbonfiberlowersupportrans[j]); + } // Placing SSD Sensor Support for(Int_t j=0; jAddNode(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 @@ -4168,11 +3810,8 @@ void AliITSv11GeometrySSD::SetLadderSegment(){ 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: @@ -4185,12 +3824,12 @@ void AliITSv11GeometrySSD::SetLadderSegment(){ 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; jAddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]); - fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]); - } + for(Int_t j=0; jAddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]); + fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]); + } } } /////////////////////////////////////////////////////////////////////////////// @@ -4254,16 +3893,10 @@ void AliITSv11GeometrySSD::SetEndLadderSegment(){ ///////////////////////////////////////////////////////////// // 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(){ @@ -4286,8 +3919,7 @@ void AliITSv11GeometrySSD::SetLadder(){ Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2) * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]); xmothervertex[0][0] = -0.5*fgkSSDSensorWidth; - ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor - - fgkSSDModuleVerticalDisalignment; + ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor; xmothervertex[0][1] = xmothervertex[0][0]; ymothervertex[0][1] = 0.0; xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax @@ -4307,16 +3939,119 @@ void AliITSv11GeometrySSD::SetLadder(){ xmothervertex[1][i] = xmothervertex[0][i]; ymothervertex[1][i] = ymothervertex[0][i]; } +/////////////////////////////////////////////////////////////////////////// +// Disalignement Mother Volume corrections 25/08/08 +/////////////////////////////////////////////////////////////////////////// + TGeoXtru* leftladdershape1[fgkladdernumber]; + TGeoXtru* leftladdershape2[fgkladdernumber]; + TGeoXtru* centersensorladdershape[fgkladdernumber]; + TGeoXtru* rightladdershape1[fgkladdernumber]; + TGeoXtru* rightladdershape2[fgkladdernumber]; + for(Int_t i=0; iSetName("Lay5Left1LadderSegmentContainer"); + leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer"); + leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer"); + leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer"); + centersensorladdershape[0]->SetName("Lay5CenterSensorContainer"); + centersensorladdershape[1]->SetName("Lay6CenterSensorContainer"); + rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer"); + rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer"); + rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer"); + rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer"); + ////////////////////////////////////// + Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber]; + Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber]; + Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber]; + Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber]; + Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber]; + Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber]; + for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xcentersensorvertex[i], + ycentersensorvertex[i]); + centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1] + + 1.45*fgkSSDMountingBlockWidth); + centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth + + fgkEndLadderCarbonFiberLowerJunctionLength[0] + - 2.4*fgkSSDMountingBlockWidth); + + // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas + + // Cuts off first corner (neg x) + xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]; + xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0]; + // Cuts off last part (pos x) + xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0]; + xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0]; + + leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i], + yend1laddervertex[i]); + leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]); + leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2] + - fgkEndLadderMountingBlockPosition[0]); + + leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i], + yend2laddervertex[i]); + leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2] + - fgkEndLadderMountingBlockPosition[0]); + leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1] + + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm + + rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i], + yend1laddervertex[i]); + rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth + +fgkEndLadderCarbonFiberLowerJunctionLength[0] + -2.4*fgkSSDMountingBlockWidth); + rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2] + + fgkEndLadderMountingBlockPosition[1]); + + rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i], + yend2laddervertex[i]); + rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2] + + fgkEndLadderMountingBlockPosition[1]); + rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth + + fgkEndLadderCarbonFiberLowerJunctionLength[0]); + } + TGeoCompositeShape* laddershapecontainer[2]; + laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape", + "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer" + "+Lay5CenterSensorContainer" + "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer"); + laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape", + "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer" + "+Lay6CenterSensorContainer" + "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer"); const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"}; for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xmothervertex[i], - ymothervertex[i]); - laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]); - laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth - +fgkEndLadderCarbonFiberLowerJunctionLength[0]); - fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir); - fladder[i]->SetLineColor(4); - } + fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir); + fladder[i]->SetLineColor(4); + } /////////////////////////////////////////////////////////////////////////// if(!fCreateMaterials) CreateMaterials(); if(!fTransformationMatrices) CreateTransformationMatrices(); @@ -4334,13 +4069,14 @@ void AliITSv11GeometrySSD::SetLadder(){ ////////////////////////// /// Placing SSD Sensor ////////////////////////// + if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed); fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1, fssdsensormatrix[i][j]); } /////////////////////////////// /// Placing End Ladder Segment /////////////////////////////// - fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]); + fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]); fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]); } ///////////////////////////////////////////////////////////////////////////// @@ -4384,12 +4120,14 @@ void AliITSv11GeometrySSD::SetLadder(){ + 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; iAddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1), + fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1), j<2?1:2,fladdercablematrix[i][j]); } } @@ -4422,7 +4160,7 @@ void AliITSv11GeometrySSD::SetLayer(){ ///////////////////////////////////////////////////////////// // Deallocating memory ///////////////////////////////////////////////////////////// - for(Int_t i=0; iSetX(-0.5*fgkSSDMountingBlockLength[0]); - mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1. - -TMath::Power(mountingsupportedgevector[i]->X() - / fgkMountingBlockSupportRadius[i],2))); + mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]); + mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt( + (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])* + (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i]))); psi0[i] = 0.5*TMath::Pi()-phi[i]; deltapsi[i] = (theta[i]+phi[i])/nedges; } @@ -4560,10 +4298,10 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ TGeoVolume* centermountingblocksupport[fgklayernumber]; TGeoVolume* sideladdersupportpiece[fgklayernumber]; TGeoVolume* centerladdersupportpiece[fgklayernumber]; - char sidemountingblockname[40]; - char centermountingblockname[40]; - char sideladdersupportpiecename[40]; - char centerladdersupportpiecename[40]; + char sidemountingblockname[100]; + char centermountingblockname[100]; + char sideladdersupportpiecename[100]; + char centerladdersupportpiecename[100]; for(Int_t i=0; iDefineSection(0,0.); centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1] -fgkMountingBlockSupportWidth[0]); + centermountingblocksupport[i] = new TGeoVolume(centermountingblockname, centermountingsupportshape[i], fSSDAlCoolBlockMedium); @@ -4630,8 +4369,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ Double_t mountingblockpieceupyvertex[fgklayernumber][8]; Double_t mountingblockpiecedownxvertex[fgklayernumber][8]; Double_t mountingblockpiecedownyvertex[fgklayernumber][8]; - char mountingblockpiecedownname[34]; - char mountingblockpieceupname[34]; + char mountingblockpiecedownname[100]; + char mountingblockpieceupname[100]; for(Int_t i=0; iSetLineColor(fColorG10); + /////////////////////////// // Mounting Block Up Vertex /////////////////////////// @@ -4675,13 +4415,13 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5); mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]; mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i] - + fgkMountingBlockSupportUpHeight[i]; + + fgkMountingBlockSupportUpHeight[i] + - fgkSSDLadderVerticalDisalignment; mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0]; mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0] + fgkSSDMountingBlockHeight[1] - 0.5*fgkCoolingTubeSupportHeight - - fgkSSDModuleCoolingBlockToSensor - - fgkSSDModuleVerticalDisalignment; + - fgkSSDModuleCoolingBlockToSensor; mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0]; mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1]; mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2]; @@ -4696,6 +4436,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5]; mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6]; mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0]; + mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i], mountingblockpieceupyvertex[i]); mountingblockpieceupshape[i]->DefineSection(0,0.0); @@ -4715,8 +4456,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5]; Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5]; Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5]; - char mountingblocksupportrapezoidowname[40]; - char mountingblocksupportrapezoidupname[40]; + char mountingblocksupportrapezoidowname[100]; + char mountingblocksupportrapezoidupname[100]; Double_t scalefactor = 3./4.; for(Int_t i=0; iDefinePolygon(5,mountingblocksupportrapezoidownxvertex[i], mountingblocksupportrapezoidownyvertex[i]); mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1] @@ -4765,6 +4507,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2]; mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3]; mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0]; + mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i], mountingblocksupportrapezoidupyvertex[i]); mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1] @@ -4780,8 +4523,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ for(Int_t i=0; iSetAngles(90.,180.,-90); TGeoRotation* globalrefladdersupportrot = new TGeoRotation(); @@ -4802,8 +4545,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ TGeoVolume* downmotherladdersupport[fgklayernumber]; TGeoXtru* upmotherladdersupportshape[fgklayernumber]; TGeoVolume* upmotherladdersupport[fgklayernumber]; - char upmotheladdersupportname[30]; - char downmotheladdersupportname[30]; + char upmotheladdersupportname[100]; + char downmotheladdersupportname[100]; for(Int_t i=0; iDefinePolygon(8,xmothervertex[i],ymothervertex[i]); downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]); - downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1] + downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1] + fgkMountingBlockSupportDownHeight + fgkSSDMountingBlockHeight[1] - 0.5*fgkCoolingTubeSupportHeight - fgkSSDModuleCoolingBlockToSensor - - 2.*fgkSSDModuleVerticalDisalignment); - downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname, - downmotherladdersupportshape[i],fSSDAir); + - fgkSSDLadderVerticalDisalignment); + +// - fgkSSDModuleVerticalDisalignment); + //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname); + + downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname, + downmotherladdersupportshape[i],fSSDAir); upmotherladdersupportshape[i] = new TGeoXtru(2); upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]); upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]); @@ -4844,8 +4593,9 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ + fgkSSDMountingBlockHeight[1] - 0.5*fgkCoolingTubeSupportHeight - fgkSSDModuleCoolingBlockToSensor - - 2.*fgkSSDModuleVerticalDisalignment); - upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname, + - fgkSSDLadderVerticalDisalignment); + + upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname, upmotherladdersupportshape[i],fSSDAir); } for(Int_t i=0; iAddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]); - downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]); + downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]); upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]); upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]); @@ -4956,15 +4707,17 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ delete [] ysidelowervertex[i]; delete [] xcenterlowervertex[i]; delete [] ycenterlowervertex[i]; + delete [] xmothervertex[i]; + delete [] ymothervertex[i]; } - delete xsidevertex; - delete ysidevertex; - delete xcentervertex; - delete ycentervertex; - delete xsidelowervertex; - delete ysidelowervertex; - delete xcenterlowervertex; - delete ycenterlowervertex; + delete [] xsidevertex; + delete [] ysidevertex; + delete [] xcentervertex; + delete [] ycentervertex; + delete [] xsidelowervertex; + delete [] ysidelowervertex; + delete [] xcenterlowervertex; + delete [] ycenterlowervertex; delete globalrefladdersupportrot; delete mountingblocksupportrot; ///////////////////// @@ -4989,7 +4742,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ for(Int_t i=0; iY()-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]; @@ -5059,7 +4812,38 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ymothervertex[i][j] = ringsupportvertex[i][j]->Y(); } } - char lowerladdersupportname[30]; +//////////////////////////////////////////////////////////////////////////////// +// Start Corrections 13/06/08 +//////////////////////////////////////////////////////////////////////////////// + char lowerladderpconsupportname[100]; + TGeoPcon* lowerladderpconsupportshape[fgklayernumber]; + TGeoVolume* lowerladderpconsupport[fgklayernumber]; + Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]}; + Double_t lowerladderpconradiusmax[fgklayernumber]; + Double_t lowerladderpconradiusmin[fgklayernumber]; + TGeoRotation* lowerladdersupportrot = new TGeoRotation(); + lowerladdersupportrot->SetAngles(90.,180.,-90); + for(Int_t i=0; iDefineSection(j, + lowerladderpconezsection[j],lowerladderpconradiusmin[i], + lowerladderpconradiusmax[i]); + sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5); + lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl); + lowerladderpconsupport[i]->SetLineColor(fColorAl); + (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1); + (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot); + } +//////////////////////////////////////////////////////////////////////////////// +// End Corrections 13/06/08 +//////////////////////////////////////////////////////////////////////////////// + /*char lowerladdersupportname[30]; TGeoXtru* lowerladdersupportshape[fgklayernumber]; TGeoVolume* lowerladdersupport[fgklayernumber]; TGeoRotation* lowerladdersupportrot = new TGeoRotation(); @@ -5076,7 +4860,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ lowerladdersupport[i]->SetLineColor(fColorAl); (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1); (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot); - } + }*/ ///////////////////////////////////////////////////////////// // Deallocating memory ///////////////////////////////////////////////////////////// @@ -5089,8 +4873,8 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ delete [] xmothervertex[i]; delete [] ymothervertex[i]; } - delete xmothervertex; - delete ymothervertex; + delete [] xmothervertex; + delete [] ymothervertex; delete globalrot; for(Int_t i=0; iSetLineColor(6); - TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius, + TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius, nendcapcoverplateholedges,holesection); TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole", endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium); @@ -5198,7 +4982,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ fSSDAlCoolBlockMedium); endcapfillingbox->SetLineColor(6); //////////////////////////// - // Contour Xtru Definition + // Contour shape Definition //////////////////////////// const Int_t kcontourvertexnumber = 10; Double_t xcontourvertex[kcontourvertexnumber]; @@ -5228,17 +5012,112 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ + fgkEndCapCoverPlateSmallHoleRadius; ycontourvertex[8] = ycontourvertex[7]; ycontourvertex[9] = ycontourvertex[0]; - TGeoXtru* contourshape = new TGeoXtru(2); - contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex); - contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); + + Double_t xboxin, dxboxin, yboxin, dyboxin; + Double_t xboxout, dxboxout, yboxout, dyboxout; + Double_t coordmin, coordmax; + coordmin = -fgkEndCapCoverPlateLength[0]; + coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2] + - (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2]); + coordmax = (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = -fgkEndCapCoverPlateSmallHoleRadius; + coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = -fgkEndCapCoverPlateSmallHoleRadius; + coordmax = (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2] + + fgkEndCapCoverPlateSmallHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin->RegisterYourself(); + TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape", + "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn"); + TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape, fSSDAlCoolBlockMedium); contour->SetLineColor(6); ///////////////////////////// - // Hole Contour Xtru Definition + // Hole Contour Shape Definition //////////////////////////// - const Int_t kholecontourvertexnumber = 10; + coordmin = xcontourvertex[0]; + coordmax = coordmin+fgkEndCapCoverPlateLength[2]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[1]; + coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius);; + coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout1->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin1->RegisterYourself(); + TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1", + "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1"); + + + coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]; + coordmax = coordmin+fgkEndCapCoverPlateLength[2]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0]); + coordmax = ycontourvertex[0]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout2->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin2->RegisterYourself(); + TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2", + "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2"); + +// const Int_t kholecontourvertexnumber = 10; + Double_t xholecontourvertex[2][kcontourvertexnumber]; Double_t yholecontourvertex[2][kcontourvertexnumber]; xholecontourvertex[0][0] = xcontourvertex[0]; @@ -5295,24 +5174,11 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ yholecontourvertex[1][8] = yholecontourvertex[1][7]; yholecontourvertex[1][9] = yholecontourvertex[1][0]; - TGeoXtru* holecontourshape[2]; - holecontourshape[0] = new TGeoXtru(2); - holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0], - yholecontourvertex[0]); - holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); - - holecontourshape[1] = new TGeoXtru(2); - holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1], - yholecontourvertex[1]); - holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); - TGeoVolume* holecontour[2]; - holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0], + holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1, fSSDAlCoolBlockMedium); holecontour[0]->SetLineColor(6); - holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1], + holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2, fSSDAlCoolBlockMedium); holecontour[1]->SetLineColor(6); TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3] @@ -5418,14 +5284,14 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ TGeoVolume* endcapcoolingtubetorus[5]; TGeoTube* endcapcoolingtubeshape[4]; TGeoVolume* endcapcoolingtube[4]; - char endcapcoolingtubetorusname[30]; - char endcapcoolingtubename[30]; + char endcapcoolingtubetorusname[100]; + char endcapcoolingtubename[100]; TGeoTorus* endcapcoolingwatertubetorushape[5]; TGeoVolume* endcapcoolingwatertubetorus[5]; TGeoTube* endcapcoolingwatertubeshape[4]; TGeoVolume* endcapcoolingwatertube[4]; - char endcapcoolingwatertubetorusname[30]; - char endcapcoolingwatertubename[30]; + 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); @@ -5792,10 +5658,19 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]; yvertex[13] = yvertex[12]; yvertex[14] = yvertex[6]; - TGeoXtru* endcapsidecovershape = new TGeoXtru(2); - endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex); - endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness); - endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness); + TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2); + endcapsidecovershapeout->SetName("endcapsidecovershapeout"); + endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex); + endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness); + endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness); + TGeoXtru* endcapsidecovershapein = new TGeoXtru(2); + endcapsidecovershapein->SetName("endcapsidecovershapein"); + endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]); + endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01); + endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01); + + + TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein"); TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover", endcapsidecovershape,fSSDCoolingTubePhynox); endcapsidecover->SetLineColor(fColorPhynox); @@ -6600,7 +6475,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness, fgkEndCapCoverPlateThickness + fgkEndCapCoolingTubeRadiusMax}; - TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius, + TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius, screwcoverplatedgesnumber, screwcoverplatesection); TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate", @@ -6873,14 +6748,13 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t radiusmax, Double_t width, Int_t ncables, - char* volname){ + const char* volname){ ///////////////////////////////////////////////////////////// // Generating EndCap High Voltage Tubes ///////////////////////////////////////////////////////////// Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin; - Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.) - + TMath::Power(radiusmax,2.) - - TMath::Power(radiusmin,2.)); + Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin)); + TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width); TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius, effectiveouteradius,0.5*width); @@ -6936,7 +6810,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ //////////////////////////////////// TGeoXtru* upendcapsupportshape[klayernumber]; TGeoVolume* upendcapsupport[klayernumber]; - char upendcapsupportname[30]; + char upendcapsupportname[100]; for(Int_t i=0; iAddNode(ssdcables,1); +} //////////////////////////////////////////////////////////////////////////////// TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){ ///////////////////////////////////////////////////////////// @@ -7538,7 +7424,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ////////////////////////////////////////////////////////////////////////////////////////////////// TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables"); Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables - Double_t ssdcablelaylateral = 0.1; // Internal variables to control overlapping with SDD cables + Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables ////////////////////////////////////////////////////////////////////////////////////////////////// Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin; @@ -7851,14 +7737,14 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t ssdcablepatchpanel3BB26radiusmin[2]; Double_t ssdcablepatchpanel3BB26radiusmax[2]; Double_t ssdcablepatchpanel3RB26zsection[2]; - ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth; + ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8; 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]; @@ -7875,10 +7761,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ 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] - + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0); + + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0); ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0); ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0] - + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0); + + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0); for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]); //////////////////////////////////// //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity(); @@ -7892,10 +7778,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ + 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]; @@ -7930,7 +7816,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcableitsring3BB26pconshape[3],fSSDCopper); for(Int_t i=0;i<4;i++){ ssdcableitsring3BB26pcon[i]->SetLineColor(9); - ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],i+1); + ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1); } //////////////////////////////////// //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity() @@ -7949,7 +7835,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1] + 0.*fgkSSDCablesLay5RightSideHeight + 0.*fgkSSDCablesLay6RightSideHeight - + 0.5*fgkSSDPatchPanelHeigth; + + 0.5*fgkSSDPatchPanelHeight; ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength - fgkSSDCentralAL3SupportLength - fgkSSDPConeZLength[0]; @@ -7965,10 +7851,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcablepatchpanel3RB24pcon->SetLineColor(9); TGeoRotation* ssdcablepatchpanel3B24rot[3]; for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation(); - ssdcablepatchpanel3B24rot[0]->SetAngles(0.0,0.0,0.0); + ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0); ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0] + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0); - ssdcablepatchpanel3B24rot[2]->SetAngles(180.0,0.0,0.0); + ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0); ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0] + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0); for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]); @@ -7982,10 +7868,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ 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]; @@ -7998,7 +7884,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle - fgkSSDCableAngle + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2); - ssdcableitsring3BB24pconshape[3] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle, + ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle, ssdcableangle-fgkSSDCableAngle + fgkSSDCablesPatchPanel2RB24Angle[0],2); for(Int_t i=0;i<4;i++) @@ -8016,7 +7902,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcableitsring3BB24pconshape[3],fSSDCopper); for(Int_t i=0;i<4;i++){ ssdcableitsring3BB24pcon[i]->SetLineColor(9); - ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],i+1); + ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1); } //////////////////////////////////// //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity() @@ -8075,36 +7961,47 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ } //////////////////////////////////////////////////////////////////////////////// TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, - Double_t height, char* shapename, Int_t isign) const{ + Double_t height, const char* shapename, Int_t isign) const{ ///////////////////////////////////////////////////////////// // Method generating an Arb shape ///////////////////////////////////////////////////////////// const Int_t kvertexnumber = 8; const Int_t ktransvectnumber = 2; - TVector3* vertex[kvertexnumber]; - TVector3* transvector[2]; - for(Int_t i=0; iSetVertex(i,vertex[i]->X(),vertex[i]->Y()); - ///////////////////////////////////////////////////////////// - // Deallocating memory - ///////////////////////////////////////////////////////////// - for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i]; - for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i]; - ///////////////////////////////////////////////////////////// + for(Int_t i = 0; iSetVertex(i,vertex[i].X(),vertex[i].Y()); + } + return arbshape; } /////////////////////////////////////////////////////////////////////////////// @@ -8157,7 +8054,7 @@ TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin, return arcshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const { +TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Screw Shape // radius[0]: outer radius @@ -8171,52 +8068,59 @@ TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumbe Double_t inradius = radius[1]; Int_t outvertexnumber = edgesnumber[0]; Int_t invertexnumber = edgesnumber[1]; - Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2]; - Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2]; - for(Int_t i=0; iDefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex); - screwshape->DefineSection(0,section[0]); - screwshape->DefineSection(1,section[1]); + TGeoXtru* screwshapeout = new TGeoXtru(2); + screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex); + screwshapeout->DefineSection(0,section[0]); + screwshapeout->DefineSection(1,section[1]); + TGeoXtru* screwshapein = new TGeoXtru(2); + screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]); + screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z + screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it + TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein); + TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode); + delete [] xscrewvertex; delete [] yscrewvertex; return screwshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const { +TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Hole Shape // radius of the Hole // nedges: number of edges to approximate the circle /////////////////////////////////////////////////////////////////////// - Int_t vertexnumber = nedges+6; - Double_t* xholevertex = new Double_t[vertexnumber]; - Double_t* yholevertex = new Double_t[vertexnumber]; - xholevertex[0] = radius; - xholevertex[1] = xholevertex[0]; - xholevertex[2] = -xholevertex[1]; - xholevertex[3] = xholevertex[2]; - xholevertex[4] = xholevertex[0]; - yholevertex[0] = 0.; - yholevertex[1] = -radius; - yholevertex[2] = yholevertex[1]; - yholevertex[3] = -yholevertex[1]; - yholevertex[4] = yholevertex[3]; - for(Int_t i=0; i TGeoShape::Tolerance()) { + tr = new TGeoTranslation(0.,0.,z); + tr->RegisterYourself(); + } + TGeoBBox *box = new TGeoBBox("",radius,radius,dz); + for(Int_t i=0; iDefinePolygon(vertexnumber,xholevertex,yholevertex); - holeshape->DefineSection(0,section[0]); - holeshape->DefineSection(1,section[1]); + TGeoXtru* holeshapeout = new TGeoXtru(2); + holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex); + holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z + holeshapeout->DefineSection(1,section[1]+0.01); + TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr); + TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode); + delete [] xholevertex; delete [] yholevertex; return holeshape; @@ -8258,11 +8162,11 @@ TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) { ///////////////////////////////////////////////////////////// // Method returning the Medium type ///////////////////////////////////////////////////////////// - char ch[30]; + char ch[100]; sprintf(ch, "ITS_%s",mediumName); TGeoMedium* medium = gGeoManager->GetMedium(ch); if (! medium) - printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName); + AliError(Form("medium %s not found !\n", mediumName)); return medium; } ////////////////////////////////////////////////////////////////////////////////