X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySSD.cxx;h=0b221e73f3785c534b06449107e3506a4e819370;hb=b5113062351878fa479f7c1b3982556e2e0bdbe8;hp=1d8abc903061d2c27c4cca58fd981628dffcb556;hpb=67446e8a13239826b073c7324c34ddcd2a53df26;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx index 1d8abc90306..0b221e73f37 100644 --- a/ITS/AliITSv11GeometrySSD.cxx +++ b/ITS/AliITSv11GeometrySSD.cxx @@ -38,11 +38,12 @@ #include "TGeoPcon.h" #include "TRotation.h" #include "AliITSv11GeometrySSD.h" + ///////////////////////////////////////////////////////////////////////////////// // Names of the Sensitive Volumes of Layer 5 and Layer 6 ///////////////////////////////////////////////////////////////////////////////// -const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5"; -const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6"; +const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5"; +const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6"; ///////////////////////////////////////////////////////////////////////////////// //Parameters for SSD Geometry ///////////////////////////////////////////////////////////////////////////////// @@ -51,6 +52,8 @@ const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6"; 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) ///////////////////////////////////////////////////////////////////////////////// @@ -85,26 +88,26 @@ const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm; -//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315; -const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength = 0.215*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5 +const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = - {44.32*fgkmm, 0.33*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, 0.33*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = - 0.25*fgkSSDStiffenerHeight; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Cooling Block (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// @@ -113,7 +116,7 @@ const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] = - {1.000*fgkmm, 0.120*fgkmm}; + {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010) const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] = {1.900*fgkmm, 0.400*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter = @@ -157,6 +160,7 @@ const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] = // SSD Ladder Cable (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam ///////////////////////////////////////////////////////////////////////////////// // SSD Module (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// @@ -314,7 +318,7 @@ const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = // Cooling Tube (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength = fgkCarbonFiberJunctionWidth; const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation = @@ -344,7 +348,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.}; @@ -381,7 +385,7 @@ const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSS + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - fgkMountingBlockSupportRadius[1]}; -const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified +const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm; const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm; ///////////////////////////////////////////////////////////////////////////////// @@ -490,7 +494,7 @@ const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fg const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm}; -const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 624.9*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm; @@ -534,7 +538,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; @@ -549,6 +553,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fSSDStiffenerConnectorMedium(), fSSDStiffener0603CapacitorMedium(), fSSDStiffener1812CapacitorMedium(), + fSSDStiffenerCapacitorCapMedium(), fSSDStiffenerHybridWireMedium(), fSSDKaptonFlexMedium(), fSSDAlTraceFlexMedium(), @@ -568,6 +573,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fSSDRohaCellCone(), fSSDAir(), fSSDCopper(), + fSSDSn(), fCreateMaterials(kFALSE), fTransformationMatrices(kFALSE), fBasicObjects(kFALSE), @@ -578,6 +584,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fcoolingblocksystematrix(), fssdstiffenerflex(), fssdendflex(), + fcoolingtube(0), fendladdercoolingtubesupportmatrix(), fendladdermountingblock(), fendladdermountingblockclip(), @@ -595,6 +602,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fColorPhynox(14), fColorSilicon(3), fColorAl(38), + fColorNiSn(40), fColorKapton(6), fColorPolyhamide(5), fColorStiffener(9), @@ -605,88 +613,80 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): //////////////////////// // Standard constructor //////////////////////// + for(Int_t i=0; i~AliITSv11GeometrySSD(); - new(this) AliITSv11GeometrySSD(s); - return *this; -/* - if(&s == this) return *this; - fMotherVol = s.fMotherVol; - return *this; - */ -} + /////////////////////////////////////////////////////////////////////////////// void AliITSv11GeometrySSD::CreateTransformationMatrices(){ /////////////////////////////////////////////////////////////////////// @@ -989,189 +989,64 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ ///////////////////////////////////////////////////////////// TGeoRotation* localcoolingtuberot = new TGeoRotation(); localcoolingtuberot->SetAngles(0.,90.,0.); - TGeoTranslation** localcoolingtubetrans[4]; - TVector3** localcoolingtubevect[4]; - for(Int_t i=0; i<4; i++){ - localcoolingtubevect[i] = new TVector3*[2]; - localcoolingtubetrans[i] = new TGeoTranslation*[2]; - fcoolingtubematrix[i] = new TGeoHMatrix*[2]; - } - localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation + TGeoTranslation* localcoolingtubetrans[2]; + TVector3* localcoolingtubevect[2]; + + localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation -fgkCarbonFiberTriangleLength), - - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth - + fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0])+ - 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength - - 2.0*fgkSSDModuleStiffenerPosition[1] - - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth) - - 0.5*fgkCoolingTubeSupportWidth, - - 0.5*fgkCoolingTubeSupportHeight); - localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(), - localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength - - 2.0*fgkSSDModuleStiffenerPosition[1] - - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth) - + fgkCoolingTubeSupportWidth, - localcoolingtubevect[0][0]->Z()); - localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[0][0]->Y(), - localcoolingtubevect[0][0]->Z()); - localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[0][1]->Y(), - localcoolingtubevect[0][1]->Z()); - localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation - - fgkCarbonFiberTriangleLength), - - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth - + fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0]) - + fgkSSDModuleStiffenerPosition[1] - - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap), - - 0.5*fgkCoolingTubeSupportHeight); - localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[2][0]->Y(), - localcoolingtubevect[2][0]->Z()); - localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation - - fgkCarbonFiberTriangleLength), - - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth - + fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0]) - + fgkSSDSensorLength - - 0.5*fgkSSDModuleStiffenerPosition[1], + fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ , - 0.5*fgkCoolingTubeSupportHeight); - localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X() - + fgkCarbonFiberTriangleLength, - localcoolingtubevect[3][0]->Y(), - - 0.5*fgkCoolingTubeSupportHeight); - for(Int_t i=0; i<4; i++) - for(Int_t j=0; j<2; j++){ - localcoolingtubetrans[i][j] = - new TGeoTranslation(localcoolingtubevect[i][j]->X(), - localcoolingtubevect[i][j]->Y(), - localcoolingtubevect[i][j]->Z()); - fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j]) - * (*localcoolingtuberot)); - } + localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength, + localcoolingtubevect[0]->Y(), + localcoolingtubevect[0]->Z()); + for(Int_t j=0; j<2; j++){ + localcoolingtubetrans[j] = + new TGeoTranslation(localcoolingtubevect[j]->X(), + localcoolingtubevect[j]->Y(), + localcoolingtubevect[j]->Z()); + fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j]) + *(*localcoolingtuberot)); + } ///////////////////////////////////////////////////////////// // SSD End Ladder Cooling Tube Transformations ///////////////////////////////////////////////////////////// TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation(); localendlladdercoolingtuberot->SetAngles(0.,90.,0.); TGeoTranslation** localendlladdercoolingtubetrans[2]; - localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6]; - localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4]; + localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2]; + localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2]; for(Int_t i=0; i<2; i++) - for(Int_t j=0; j<(i==0?6:4); j++) + for(Int_t j=0; j<2; j++) localendlladdercoolingtubetrans[i][j] = new TGeoTranslation(); + + Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ; localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength - fgkCoolingTubeSupportRmax) + fgkCarbonFiberJunctionLength, - 0.5*(fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[0]), + 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift), - 0.5*fgkCoolingTubeSupportHeight); localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength - fgkCoolingTubeSupportRmax) - fgkCarbonFiberJunctionLength + fgkCarbonFiberTriangleLength, - 0.5*(fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[0]), + 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift), - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - + fgkCarbonFiberJunctionLength, - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[0] - + 0.5*(fgkendladdercoolingsupportdistance[0] - + fgkendladdercoolingsupportdistance[1] - + fgkCoolingTubeSupportWidth), - - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - - fgkCarbonFiberJunctionLength - + fgkCarbonFiberTriangleLength, - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[0] - + 0.5*(fgkendladdercoolingsupportdistance[0] - + fgkendladdercoolingsupportdistance[1] - + fgkCoolingTubeSupportWidth), - - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - + fgkCarbonFiberJunctionLength, - fgkEndLadderCarbonFiberLowerJunctionLength[0] - - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0] - - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth), - - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - - fgkCarbonFiberJunctionLength - + fgkCarbonFiberTriangleLength, - fgkEndLadderCarbonFiberLowerJunctionLength[0] - - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0] - - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth), - - 0.5*fgkCoolingTubeSupportHeight); + localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - + fgkCarbonFiberJunctionLength, - - 0.50 * (fgkMountingBlockToSensorSupport - - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth) - - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1] - + fgkSSDSensorOverlap - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkEndLadderMountingBlockPosition[1] - - fgkCoolingTubeSupportWidth) - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkCoolingTubeSupportWidth, + - fgkCoolingTubeSupportRmax) + + fgkCarbonFiberJunctionLength, + 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift), - 0.5*fgkCoolingTubeSupportHeight); localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength - fgkCoolingTubeSupportRmax) - fgkCarbonFiberJunctionLength + fgkCarbonFiberTriangleLength, - - 0.50 * (fgkMountingBlockToSensorSupport - - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth) - - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1] - + fgkSSDSensorOverlap - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkEndLadderMountingBlockPosition[1] - - fgkCoolingTubeSupportWidth) - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkCoolingTubeSupportWidth, + 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift), - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - + fgkCarbonFiberJunctionLength, - fgkEndLadderCarbonFiberLowerJunctionLength[1] - - 0.5*fgkendladdercoolingsupportdistance[2], - - 0.5*fgkCoolingTubeSupportHeight); - localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax) - - fgkCarbonFiberJunctionLength - + fgkCarbonFiberTriangleLength, - fgkEndLadderCarbonFiberLowerJunctionLength[1] - - 0.5*fgkendladdercoolingsupportdistance[2], - - 0.5*fgkCoolingTubeSupportHeight); - fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6]; - fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4]; for(Int_t i=0; i<2; i++) - for(Int_t j=0; j<(i==0?6:4); j++){ + for(Int_t j=0; j<2; j++){ fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot); fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]); } @@ -1201,19 +1076,12 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ ///////////////////////////////////////////////////////////// // SSD Cooling Block Transformations ///////////////////////////////////////////////////////////// - const Int_t kcoolingblockmatrixnumber = 4; - TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber]; - localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax - - fgkCoolingTubeSupportRmin),0.0, - 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax)); - localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength - - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength, - 0.0,fgkSSDStiffenerHeight); - localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]); - localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]); - fcoolingblocksystematrix = new TGeoHMatrix(); - for(Int_t i=0; iMultiplyLeft(localcoolingblocktrans[i]); + TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0] + - 0.5*fgkSSDCoolingBlockLength, + fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth, + fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+ + 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax)); + fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans); ///////////////////////////////////////////////////////////// // SSD Stiffener Flex Transformations ///////////////////////////////////////////////////////////// @@ -1279,21 +1147,21 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber]; for(Int_t i=0; iSetAngles(120.*j,0.,0.); for(Int_t i=0; iSetTranslation(fgkCarbonFiberTriangleLength, @@ -1318,7 +1186,7 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ *localendladdercarbonfiberjunctionglobalrot[i]); } for(Int_t i=0; iSetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance); fendladderlowersupptrans[2] = new TGeoTranslation(0.0, fgkCarbonFiberLowerSupportVolumePosition[1] + fgkCarbonFiberLowerSupportVolumePosition[0], @@ -1442,6 +1311,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 //////////////////////////////////////////// @@ -1544,8 +1415,9 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.); } for(Int_t i=0; iMultiplyLeft(ladderglobalmatrix[1][i]); + for(Int_t j=0; jMultiplyLeft(ladderglobalmatrix[1][i]); + /////////////////////////////////////////// // Setting Ladder HMatrix /////////////////////////////////////////// @@ -1582,6 +1454,7 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ - fgkLowerSupportToSensorZ, 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight -fgkSSDModuleCoolingBlockToSensor); + for(Int_t i=0; i<2; i++) localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i], *localssdsensorrot); @@ -1714,17 +1587,12 @@ 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 ///////////////////////////////////////////////////////////// @@ -1927,9 +1790,9 @@ void AliITSv11GeometrySSD::SetSSDSensor(){ 0.5*fgkSSDSensorHeight, 0.5*ssdsensitivelength); TGeoVolume* ssdsensorsensitiveLay5 = - new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium); + new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium); TGeoVolume* ssdsensorsensitiveLay6 = - new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium); + new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium); ssdsensorsensitiveLay5->SetLineColor(fColorSilicon); ssdsensorsensitiveLay6->SetLineColor(fColorSilicon); TGeoBBox* ssdsensorinsensitiveshape[2]; @@ -2016,8 +1879,8 @@ TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){ Double_t* param = new Double_t[4]; param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition; for(Int_t j=0; jX(), - (GetReflection(vertexposition[0][j],param))->Y()); + new TVector3((GetReflection(vertexposition[0][j],param))->X(), + (GetReflection(vertexposition[0][j],param))->Y()); const char* carbonfibersupportshapename[kshapesnumber] = {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"}; const char* carbonfibersupportname[kshapesnumber] = @@ -2057,8 +1920,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] @@ -2067,9 +1930,9 @@ TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){ fgkCarbonFiberJunctionEdge[0] * TMath::Sin(fgkCarbonFiberJunctionAngle[0] * TMath::DegToRad())); - vertex[4] = new TVector3(fgkCarbonFiberJunctionLength, + vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance, fgkCarbonFiberJunctionEdge[1]); - vertex[5] = new TVector3(fgkCarbonFiberJunctionLength); + vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance); vertex[1] = GetReflection(vertex[5],reflectionparam); vertex[2] = GetReflection(vertex[4],reflectionparam); Double_t xvertexpoints[6], yvertexpoints[6]; @@ -2149,7 +2012,7 @@ TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){ } /////////////////////////////////////////////////////////////////////////////// TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height, - Double_t width, Double_t* thickness)const{ + Double_t width, const Double_t* thickness)const{ ///////////////////////////////////////////////////////////// // Method generating the Sensor Support ///////////////////////////////////////////////////////////// @@ -2194,8 +2057,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(), @@ -2204,10 +2069,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 //////////////////////////////////////// @@ -2334,18 +2202,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]; ///////////////////////////////////////////////////////////// @@ -2370,54 +2238,47 @@ 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); - ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]); + xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth; + ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight; + xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth; + ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight + -fgkSSDChipCablesHeight[i+2]; + + xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth; + ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2]; + xmothervertex[i][3] = xmothervertex[i][2]; + ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance; + + xmothervertex[i][4] = xmothervertex[i][2]-0.4; + ymothervertex[i][4] = ymothervertex[i][3]; + xmothervertex[i][5] = xmothervertex[i][4]; + ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance; + + xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm; + ymothervertex[i][6] = ymothervertex[i][5]; + + xmothervertex[i][7] = xmothervertex[i][6]; + ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight; + TGeoXtru *shape = new TGeoXtru(2); + shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]); + shape->DefineSection(0,-0.5*fgkSSDStiffenerLength); + shape->DefineSection(1,0.5*fgkSSDStiffenerLength); + ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir); + ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir); + ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]); } ///////////////////////////////////////////////////////////// // SSD Stiffener @@ -2429,52 +2290,83 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape, fSSDStiffenerMedium); ssdstiffener->SetLineColor(fColorStiffener); - TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber]; - for(Int_t i=0; iSetLineColor(fColorAl); + TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.); + capacitor0603mother->AddNode(capacitor0603,1,cap0603trans); + + TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape", + 0.5*fgkSSDCapacitor0603CapLength, + 0.5*fgkSSDCapacitor0603Width, + 0.5*fgkSSDCapacitor0603Height); + TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape, + fSSDStiffenerCapacitorCapMedium); + capacitor0603cap->SetLineColor(fColorNiSn); + TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.); + capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1); + TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.); + capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2); + + + TGeoVolume* ssdchip = GetSSDChip(); + + const Int_t knedges = 5; + TGeoVolume *ssdchipcables[2]; + for(Int_t i=0; iAddNode(ssdstiffener,1,hybridmotherrotInv); + for(Int_t k=1; kAddNode(capacitor0603mother,k, + new TGeoCombiTrans("", + -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width), + -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height), + (k-3.)/6*fgkSSDStiffenerLength, + hybridmotherrotInv)); + } + } + + GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges); + for(Int_t k=0; 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]; @@ -2508,25 +2400,31 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ //////////////////////////// // Connector /////////////////////////// - const Int_t kssdconnectornumber = 2; - TGeoBBox* ssdconnectorshape[kssdconnectornumber]; + const Int_t kssdconnectorlayernumber = 3; + TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber]; + Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight}; + /* Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)}; Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight) + fgkSSDConnectorAlHeight}; - const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"}; - TGeoVolume* ssdconnector[kssdconnectornumber]; - for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : fColorPhynox); + ssdConnectorMedium[i]); + ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn); } - TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber]; + const Int_t kssdconnectornumber = 4; + TGeoTranslation* ssdconnectortrans[kssdconnectornumber]; ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX() + fgkSSDConnectorPosition[0] - fgkSSDConnectorSeparation @@ -2554,25 +2452,49 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ -(ssdstiffenershape->GetDY() - fgkSSDConnectorPosition[1] - ssdconnectorshape[0]->GetDY()),0.0); - for(Int_t i=0; i<2*kssdconnectornumber; i++) - for(Int_t j=0; jAddNode(ssdconnector[j],i+1,ssdconnectortrans[i]); + for(Int_t i=0; iAddNode(ssdconnector[j],i+1,ssdconnectortrans[i]); + } //////////////////////////// // Capacitor 1812-330 nF /////////////////////////// - Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)}; +// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)}; TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape", 0.5*fgkSSDCapacitor1812Length, 0.5*fgkSSDCapacitor1812Width, - 0.5*fgkSSDCapacitor1812Height, - ssdcapacitor1812origin); + 0.5*fgkSSDCapacitor1812Height); + // ssdcapacitor1812origin); TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape, fSSDStiffener1812CapacitorMedium); capacitor1812->SetLineColor(fColorAl); TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0, 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation - - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0); + - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)); ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans); + + TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape", + 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width, + 0.5*fgkSSDCapacitor1812Height); + TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape, + fSSDStiffenerCapacitorCapMedium); + capacitor1812cap->SetLineColor(fColorNiSn); + TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation( + - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(), + 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation + - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1], + 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)); + ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1); + TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation( + capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(), + 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation + - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1], + 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)); + ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2); + //////////////////////////// //Hybrid Wire //////////////////////////// @@ -2581,8 +2503,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); @@ -2596,7 +2518,7 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth, ssdstiffenershape->GetDZ() - + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight, + + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight, new TGeoRotation("HybridWireRot1",0.,90.,0.)); hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2", 0.0, @@ -2614,7 +2536,6 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ ///////////////////////////////////////////////////////////// delete hybridwirecombitrans[0]; delete hybridwirecombitrans[1]; - delete ssdchipsystemlist; return ssdhybridlist; ///////////////////////////////////////////////////////////// } @@ -2629,116 +2550,39 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){ localcoolingblockrot->SetAngles(0.,90.,0.); TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot); TVector3* coolingblocktransvector; - coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance - + fgkSSDCoolingBlockLength, + coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation, fgkSSDSensorLength - 2.*fgkSSDModuleStiffenerPosition[1] - fgkSSDCoolingBlockWidth); const Int_t kcoolingblocktransnumber = 2; const Int_t kcoolingblocknumber = 4; TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber]; - TGeoHMatrix* coolingtubematrix[kcoolingblocknumber]; TGeoRotation* localcoolingtuberot = new TGeoRotation(); localcoolingtuberot->SetAngles(0.0,90.0,0.0); - TGeoTranslation* localcoolingtubetrans = new TGeoTranslation(); - localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength, - 0.5*fgkSSDCoolingBlockWidth, - fgkSSDCoolingBlockHoleCenter); - TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot); - Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin; for(Int_t i=0; iX()+2*coolingtubedistance, + TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance, j*coolingblocktransvector->Y(), - 0.5*(fgkSSDCoolingBlockHoleCenter + fgkCoolingTubeRmax)); coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix); - coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix); } } - ///////////////////////////////////////////////////////////// - // Virtual Volume containing CoolingBlock System - ///////////////////////////////////////////////////////////// - TGeoXtru* coolingsystemothershape = new TGeoXtru(2); - const Int_t kmothervertexnumber = 16; - Double_t xmothervertex[kmothervertexnumber]; - Double_t ymothervertex[kmothervertexnumber]; - /////////////////////// - // Setting the vertices - ///////////////////////fgkCoolingTubeSupportRmax - xmothervertex[0] = 0.0,ymothervertex[0] = 0.0; - xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y() - + fgkSSDCoolingBlockWidth; - xmothervertex[2] = coolingblocktransvector->X() - + fgkSSDCoolingBlockLength - + 4*coolingtubedistance; - ymothervertex[2] = ymothervertex[1]; - xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0]; - xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength; - ymothervertex[4] = ymothervertex[0]; - xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth; - xmothervertex[6] = xmothervertex[3]-coolingtubedistance; - ymothervertex[6] = ymothervertex[5]; - xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2] - - fgkSSDCoolingBlockWidth; - xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7]; - xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2] - - coolingtubedistance; - xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance; - ymothervertex[10] = ymothervertex[9]; - xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8]; - xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11]; - xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth; - xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength; - ymothervertex[14] = ymothervertex[13]; - xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0]; - ////////////////////////////////////////////////////////// - coolingsystemothershape->DefinePolygon(kmothervertexnumber, - xmothervertex,ymothervertex); - coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter - + fgkCoolingTubeRmax)); - coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter - + fgkCoolingTubeRmax)); TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem"); -// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem", -// coolingsystemothershape,fSSDAir); - ///////////////////////////////////////////////////////////// - // SSD Cooling Tube Part - ///////////////////////////////////////////////////////////// - TGeoTube* coolingtubeshape[fgkcoolingtubenumber]; - coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance)); - coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance)); - TGeoVolume* coolingtube[fgkcoolingtubenumber]; - coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0], - fSSDCoolingTubePhynox); - coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1], - fSSDCoolingTubeWater); - coolingtube[0]->SetLineColor(fColorPhynox); - coolingtube[1]->SetLineColor(fColorWater); TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30); ///////////////////////////////////////////////////////////// // Adding Cooling block to mother volume ///////////////////////////////////////////////////////////// - for(Int_t i=0; 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{ @@ -3039,6 +2883,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ - fgkSSDMountingBlockHeight[0]; yvertex[6] = yvertex[5]; yvertex[7] = yvertex[0]; + /////////////////////////////////////////////////////////////////////// // TGeoXTru Volume definition for Mounting Block Part /////////////////////////////////////////////////////////////////////// @@ -3160,11 +3005,11 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2]; ymothervertex[6] = ymothervertex[5]; xmothervertex[7] = xmothervertex[6]; - ymothervertex[7] = ymothervertex[4]; + ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance; xmothervertex[8] = xmothervertex[7] + 0.5*(fgkSSDMountingBlockLength[1] - fgkSSDMountingBlockLength[2]); - ymothervertex[8] = ymothervertex[4]; + ymothervertex[8] = ymothervertex[7]; xmothervertex[9] = xmothervertex[8]; ymothervertex[9] = ymothervertex[2]; xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0]; @@ -3229,6 +3074,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 /////////////////////////////////////////////////////////////////////// @@ -3318,185 +3164,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-fgkSSDTolerance)); - coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - coolingtubeshape[1][0]->GetDz()); - coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDTolerance)); - coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - coolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance); - // End Ladder Cooling Tubes - TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber]; - for(Int_t i=0; iGetDz()); - endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkendladdercoolingsupportdistance[0] - + fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth-fgkSSDTolerance)); - endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance); - endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0] - - fgkEndLadderMountingBlockPosition[0] - - fgkendladdercoolingsupportdistance[1] - - fgkCoolingTubeSupportWidth-fgkSSDTolerance)); - endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance); - endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkMountingBlockToSensorSupport - - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth) - - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1] - + fgkSSDSensorOverlap - + fgkEndLadderCarbonFiberLowerJunctionLength[1] - - fgkendladdercoolingsupportdistance[2] - - fgkEndLadderMountingBlockPosition[1] - - fgkCoolingTubeSupportWidth-fgkSSDTolerance)); - endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[3][0]->GetDz()-0.5*fgkSSDTolerance); - endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, - 0.50 * (fgkendladdercoolingsupportdistance[2]-fgkSSDTolerance)); - endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[4][0]->GetDz()-0.5*fgkSSDTolerance); - // Ladder Cooling Tubes - TGeoVolume** coolingtube[fgkcoolingtubenumber]; - for(Int_t i=0; 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){ @@ -3566,20 +3314,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,20 +3359,18 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Double_t phi = 180.; Double_t deltaphi = 180./nedges; Double_t angle = 0.0; - Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber]; - Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber]; - for(Int_t i=0; iAddNode(ssdchipcable[0],1,ssdchipcablesrot[4]); - ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]); - ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans); - ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans); + static const Int_t kmothervertexnumber = 8; + Double_t xmothervertex[kmothervertexnumber]; + Double_t ymothervertex[kmothervertexnumber]; + xmothervertex[0] = xvertexpoints[0][1]; + ymothervertex[0] = yvertexpoints[0][1]; + xmothervertex[1] = xvertexpoints[0][2+nedges/2]; + ymothervertex[1] = yvertexpoints[0][1]; + xmothervertex[2] = xvertexpoints[0][2+nedges/2]; + ymothervertex[2] = yvertexpoints[0][2+nedges]; + xmothervertex[3] = xvertexpoints[0][3+nedges]; + ymothervertex[3] = yvertexpoints[0][3+nedges]; + xmothervertex[4] = xvertexpoints[0][3+2*nedges]; + ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance; + xmothervertex[5] = xvertexpoints[0][4+2*nedges]; + ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance; + xmothervertex[6] = xvertexpoints[1][5+2*nedges]; + ymothervertex[6] = yvertexpoints[1][5+2*nedges]; + xmothervertex[7] = xvertexpoints[0][1]; + ymothervertex[7] = yvertexpoints[1][5+2*nedges]; + TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2); + ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex); + ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]); + ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]); + + cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir); + cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir); + + cableL->AddNode(ssdchipcable[0],1); + cableL->AddNode(ssdchipcable[1],1); + cableR->AddNode(ssdchipcable[2],1); + cableR->AddNode(ssdchipcable[3],1); + ///////////////////////////////////////////////////////////// // Deallocating memory ///////////////////////////////////////////////////////////// - for(Int_t i=0; 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); - chipsystemother[i] = new TGeoVolumeAssembly(chipsytemothername[i]); - } - ///////////////////////////////////////////////////////////// - // SSD Chip Cables - ///////////////////////////////////////////////////////////// - TGeoVolume* ssdchipcables[kchipsystemnumber]; - TGeoRotation** ssdchipcablesrot[kchipsystemnumber]; - TGeoTranslation** ssdchipcablestrans[kchipsystemnumber]; - TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber]; - ////////////////// - for(Int_t i=0; 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); - TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer"); - ///////////////////////////////////////////////////////////// - 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*fgkSSDLadderCableHeight[0]), + new TGeoTranslation("LadderCableSegmentBBoxTrans2", + 0.5*fgkSSDFlexWidth[0], + 0.5*fgkSSDLadderCableWidth, + fgkSSDLadderCableHeight[0] + +0.5*fgkSSDLadderCableHeight[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]); @@ -4006,7 +3591,7 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}}; const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] = {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"}; - TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber]; + for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] = GetArbShape(laddercablesegmentvertexposition[i], laddercablesegmentwidth[i], @@ -4014,7 +3599,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] = @@ -4050,7 +3635,7 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen new TGeoBBox(ladderendcablesegmentbboxshapename[i], 0.5*ssdendladdercablelength, 0.5*fgkSSDLadderCableWidth, - 0.5*fgkSSDFlexHeight[i]); + 0.5*fgkSSDLadderCableHeight[i]); const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] = {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"}; TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber]; @@ -4068,13 +3653,13 @@ TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelen new TGeoTranslation("LadderEndCableSegmentBBoxTrans0", 0.5*ssdendladdercablelength, 0.5*fgkSSDLadderCableWidth, - 0.5*fgkSSDFlexHeight[0]); + 0.5*fgkSSDLadderCableHeight[0]); ladderendcablesegmentbboxtrans[1] = new TGeoTranslation("LadderEndCableSegmentBBoxTrans1", 0.5*ssdendladdercablelength, 0.5*fgkSSDLadderCableWidth, - fgkSSDFlexHeight[0] - +0.5*fgkSSDFlexHeight[1]); + fgkSSDLadderCableHeight[0] + +0.5*fgkSSDLadderCableHeight[1]); TGeoVolume* ladderendcablesegmentbboxassembly = new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly"); for(Int_t i=0; iAdd(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"); @@ -4098,43 +3685,48 @@ TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladderc TGeoTranslation* laddercabletrans = new TGeoTranslation( i*(fgkCarbonFiberJunctionWidth), fgkSSDLadderCableWidth-fgkSSDFlexWidth[0], - i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])); + i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])); laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans); - if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); + if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); + } TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans", (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0], - fgkSSDLadderCableWidth-fgkSSDFlexWidth[0], - (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])); + fgkSSDLadderCableWidth-fgkSSDFlexWidth[0], + (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])); laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans); return laddercable; } ///////////////////////////////////////////////////////////////////////////////// TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){ - ///////////////////////////////////////////////////////////// - // Method generating Ladder Cable Volumes Assembly - ///////////////////////////////////////////////////////////// - TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly"); - 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*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])}; + TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig); + TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir); + char laddercabletransname[100]; for(Int_t i=0; iAddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, - new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.)); + snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1); + laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, + new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0)); } - return laddercableassembly; + return laddercable; } ///////////////////////////////////////////////////////////////////////////////// TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){ ///////////////////////////////////////////////////////////// // Method generating Ladder Cable List Assemblies + // containing two cables bundles, i.e. P+N readout for one endcap ///////////////////////////////////////////////////////////// - const Int_t kladdercableassemblynumber = 2; + const Int_t kladdercableassemblynumber = 2; TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength); TGeoVolume* ladderCable[kladdercableassemblynumber]; - char laddercableassemblyname[30]; + char laddercableassemblyname[100]; TList* laddercableassemblylist = new TList(); for(Int_t i=0; iAddNode(laddercableassembly,i+1,i==0 ? NULL : new TGeoCombiTrans((n-1) @@ -4152,6 +3744,19 @@ void AliITSv11GeometrySSD::SetLadderSegment(){ ///////////////////////////////////////////////////////////// fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1"); fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2"); + + /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis + TGeoXtru *laddersegmentshape = new TGeoXtru(2); + static const Int_t ntrianglevtx = 3; + Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0}; + Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())}; + laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx); + laddersegmentshape->DefineSection(0,0); + laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL + fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir); + fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir); + */ + if(!fCreateMaterials) CreateMaterials(); if(!fTransformationMatrices) CreateTransformationMatrices(); if(!fBasicObjects) CreateBasicObjects(); @@ -4164,16 +3769,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 @@ -4181,11 +3788,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: @@ -4198,12 +3802,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]); + } } } /////////////////////////////////////////////////////////////////////////////// @@ -4219,7 +3823,7 @@ void AliITSv11GeometrySSD::SetEndLadderSegment(){ if(!fTransformationMatrices) CreateTransformationMatrices(); if(!fBasicObjects) CreateBasicObjects(); for(Int_t i=0; iAddNode(j==2 ? fendladdercarbonfiberjunction[i][1] : fendladdercarbonfiberjunction[i][0], @@ -4267,16 +3871,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(){ @@ -4297,11 +3895,11 @@ void AliITSv11GeometrySSD::SetLadder(){ // Setting the vertices /////////////////////// Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2) - * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]); + * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]); xmothervertex[0][0] = -0.5*fgkSSDSensorWidth; ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor; xmothervertex[0][1] = xmothervertex[0][0]; - ymothervertex[0][1] = 0.0; + ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax - laddercablethickness/SinD(2.*fgkSSDFlexAngle); ymothervertex[0][2] = ymothervertex[0][1]; @@ -4322,88 +3920,116 @@ void AliITSv11GeometrySSD::SetLadder(){ /////////////////////////////////////////////////////////////////////////// // Disalignement Mother Volume corrections 25/08/08 /////////////////////////////////////////////////////////////////////////// - TGeoXtru* leftladdershape[fgkladdernumber]; + TGeoXtru* leftladdershape1[fgkladdernumber]; + TGeoXtru* leftladdershape2[fgkladdernumber]; TGeoXtru* centersensorladdershape[fgkladdernumber]; - TGeoXtru* rightladdershape[fgkladdernumber]; + TGeoXtru* rightladdershape1[fgkladdernumber]; + TGeoXtru* rightladdershape2[fgkladdernumber]; for(Int_t i=0; iSetName("Lay5LeftLadderSegmentContainer"); - leftladdershape[1]->SetName("Lay6LeftLadderSegmentContainer"); + leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer"); + leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer"); + leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer"); + leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer"); centersensorladdershape[0]->SetName("Lay5CenterSensorContainer"); centersensorladdershape[1]->SetName("Lay6CenterSensorContainer"); - rightladdershape[0]->SetName("Lay5RightLadderSegmentContainer"); - rightladdershape[1]->SetName("Lay6RightLadderSegmentContainer"); + rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer"); + rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer"); + rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer"); + rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer"); ////////////////////////////////////// - Double_t xleftladdervertex[fgkladdernumber][kmothervertexnumber]; - Double_t yleftladdervertex[fgkladdernumber][kmothervertexnumber]; + Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber]; + Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber]; Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber]; Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber]; - Double_t xrightladdervertex[fgkladdernumber][kmothervertexnumber]; - Double_t yrightladdervertex[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); - xcentersensorvertex[1][0] = xcentersensorvertex[0][0]; - xcentersensorvertex[1][1] = xcentersensorvertex[0][1]; - xcentersensorvertex[1][6] = xcentersensorvertex[0][6]; - xcentersensorvertex[1][7] = xcentersensorvertex[0][7]; + // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas - ycentersensorvertex[0][0] -= fgkSSDModuleVerticalDisalignment; - ycentersensorvertex[0][7] = ycentersensorvertex[0][0]; + // 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]; - ycentersensorvertex[1][0] = ycentersensorvertex[0][0]; - ycentersensorvertex[1][7] = ycentersensorvertex[0][7]; - for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xleftladdervertex[i], - yleftladdervertex[i]); - leftladdershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]); - leftladdershape[i]->DefineSection(1,-fgkEndLadderCarbonFiberLowerJunctionLength[1] - +1.45*fgkSSDMountingBlockWidth); - // Center Ladder Piece - centersensorladdershape[i]->DefinePolygon(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); - // Right Ladder Piece - rightladdershape[i]->DefinePolygon(kmothervertexnumber,xrightladdervertex[i], - yrightladdervertex[i]); - rightladdershape[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth - +fgkEndLadderCarbonFiberLowerJunctionLength[0] - -2.4*fgkSSDMountingBlockWidth); - rightladdershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth - +fgkEndLadderCarbonFiberLowerJunctionLength[0]); - } - TGeoCompositeShape* laddershapecontainer[2]; - laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape", - "Lay5LeftLadderSegmentContainer+Lay5CenterSensorContainer+Lay5RightLadderSegmentContainer"); - laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape", - "Lay6LeftLadderSegmentContainer+Lay6CenterSensorContainer+Lay6RightLadderSegmentContainer"); - const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"}; - for(Int_t i=0; iSetLineColor(4); - } + 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; iSetLineColor(4); + } /////////////////////////////////////////////////////////////////////////// if(!fCreateMaterials) CreateMaterials(); if(!fTransformationMatrices) CreateTransformationMatrices(); @@ -4428,7 +4054,7 @@ void AliITSv11GeometrySSD::SetLadder(){ /////////////////////////////// /// 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]); } ///////////////////////////////////////////////////////////////////////////// @@ -4470,8 +4096,11 @@ void AliITSv11GeometrySSD::SetLadder(){ - fgkSSDModuleStiffenerPosition[1] - fgkSSDStiffenerWidth) + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection; + TList* laddercableassemblylist[4]; const Int_t kendladdercablesnumber = 4; + TGeoRotation *laddercablerot = new TGeoRotation(); + laddercablerot->SetAngles(90.,60.,-90.); for(Int_t i=0; 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; } @@ -4648,16 +4277,16 @@ 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; iDefinePolygon(vertexlist[i]->GetSize()+2, xsidevertex[i],ysidevertex[i]); sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1] @@ -4673,6 +4302,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ centermountingsupportshape[i]->DefineSection(0,0.); centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1] -fgkMountingBlockSupportWidth[0]); + centermountingblocksupport[i] = new TGeoVolume(centermountingblockname, centermountingsupportshape[i], fSSDAlCoolBlockMedium); @@ -4718,17 +4348,18 @@ 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 /////////////////////////// mountingblockpieceupshape[i] = new TGeoXtru(2); - sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5); + snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5); mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]; mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i] - + fgkMountingBlockSupportUpHeight[i]; + + fgkMountingBlockSupportUpHeight[i] + - fgkSSDLadderVerticalDisalignment; mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0]; mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0] + fgkSSDMountingBlockHeight[1] @@ -4782,6 +4415,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); @@ -4801,8 +4435,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] -fgkMountingBlockSupportWidth[0]); mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]); - sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5); + snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5); mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname, mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium); mountingblocksupportrapezoidown[i]->SetLineColor(9); @@ -4851,12 +4486,13 @@ 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] -fgkMountingBlockSupportWidth[0]); mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]); - sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5); + snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5); mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname, mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium); mountingblocksupportrapezoidup[i]->SetLineColor(9); @@ -4866,8 +4502,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ for(Int_t i=0; iSetAngles(90.,180.,-90); TGeoRotation* globalrefladdersupportrot = new TGeoRotation(); @@ -4887,10 +4523,9 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ TGeoXtru* downmotherladdersupportshape[fgklayernumber]; TGeoVolume* downmotherladdersupport[fgklayernumber]; TGeoXtru* upmotherladdersupportshape[fgklayernumber]; -// TGeoVolume* upmotherladdersupport[fgklayernumber]; - TGeoVolumeAssembly* upmotherladdersupport[fgklayernumber]; - char upmotheladdersupportname[30]; - char downmotheladdersupportname[30]; + TGeoVolume* upmotherladdersupport[fgklayernumber]; + 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); - downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname, - downmotherladdersupportshape[i],fSSDAir); + - fgkSSDModuleCoolingBlockToSensor + - 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]); @@ -4929,10 +4571,11 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ + fgkMountingBlockSupportUpHeight[i] + fgkSSDMountingBlockHeight[1] - 0.5*fgkCoolingTubeSupportHeight - - fgkSSDModuleCoolingBlockToSensor); - upmotherladdersupport[i] = new TGeoVolumeAssembly(upmotheladdersupportname); -// upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname, -// upmotherladdersupportshape[i],fSSDAir); + - fgkSSDModuleCoolingBlockToSensor + - fgkSSDLadderVerticalDisalignment); + + upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname, + upmotherladdersupportshape[i],fSSDAir); } for(Int_t i=0; iSetLineColor(9); mountingblocksupportboxup[i][j]->SetLineColor(9); for(Int_t k=0; k<2; k++){ downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]); } } for(Int_t k=0; k<2; k++){ @@ -5010,14 +4654,14 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]); - downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]); + downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]); downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]); upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]); -// upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]); + upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]); } } TList* laddersupportlist = new TList(); @@ -5042,15 +4686,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; ///////////////////// @@ -5075,7 +4721,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]; @@ -5148,7 +4794,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ //////////////////////////////////////////////////////////////////////////////// // Start Corrections 13/06/08 //////////////////////////////////////////////////////////////////////////////// - char lowerladderpconsupportname[30]; + char lowerladderpconsupportname[100]; TGeoPcon* lowerladderpconsupportshape[fgklayernumber]; TGeoVolume* lowerladderpconsupport[fgklayernumber]; Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]}; @@ -5159,7 +4805,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ for(Int_t i=0; iDefineSection(j, lowerladderpconezsection[j],lowerladderpconradiusmin[i], lowerladderpconradiusmax[i]); - sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5); + snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5); lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl); lowerladderpconsupport[i]->SetLineColor(fColorAl); (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1); @@ -5206,8 +4852,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; iAddNode(holecontour[0],2,holecontourtrans); mothercoverplate->AddNode(holecontour[1],1); mothercoverplate->AddNode(contour,1); + + for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++) + delete [] endcapcoverplatesmallholetrans[i]; + delete [] endcapcoverplatesmallholetrans; ///////////////////////////////// return mothercoverplate; } @@ -5617,39 +5267,39 @@ 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); - sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1); - sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1); - if(i==3){ - endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0], - fgkEndCapCoolingTubeRadiusMin, - fgkEndCapCoolingTubeRadiusMax, - 90.0,fgkEndCapCoolingTubeAngle[3]); - endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0], - 0.,fgkEndCapCoolingTubeRadiusMin, - 90.0,fgkEndCapCoolingTubeAngle[3]); + snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1); + snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1); + snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1); + snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1); + if(i==3){ + endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0], + fgkEndCapCoolingTubeRadiusMin, + fgkEndCapCoolingTubeRadiusMax, + 90.0,fgkEndCapCoolingTubeAngle[3]); + endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0], + 0.,fgkEndCapCoolingTubeRadiusMin, + 90.0,fgkEndCapCoolingTubeAngle[3]); + } + else{ + endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0] + :fgkEndCapCoolingTubeAxialRadius[1], + fgkEndCapCoolingTubeRadiusMin, + fgkEndCapCoolingTubeRadiusMax, + 0.,fgkEndCapCoolingTubeAngle[i]); + endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0] + :fgkEndCapCoolingTubeAxialRadius[1], + 0.,fgkEndCapCoolingTubeRadiusMin, + 0.,fgkEndCapCoolingTubeAngle[i]); } - else{ - endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0] - :fgkEndCapCoolingTubeAxialRadius[1], - fgkEndCapCoolingTubeRadiusMin, - fgkEndCapCoolingTubeRadiusMax, - 0.,fgkEndCapCoolingTubeAngle[i]); - endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0] - :fgkEndCapCoolingTubeAxialRadius[1], - 0.,fgkEndCapCoolingTubeRadiusMin, - 0.,fgkEndCapCoolingTubeAngle[i]); - } endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname, endcapcoolingtubetorushape[i], fSSDCoolingTubePhynox); @@ -6090,7 +5740,8 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3 +i*(kendcapcoverholenumber[1]-1)+j]); } - return endcapsidecovermother; + delete [] endcapsidecoverboxtrans; + return endcapsidecovermother; } //////////////////////////////////////////////////////////////////////////////// TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const { @@ -7086,9 +6737,8 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ // 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); @@ -7144,10 +6794,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ //////////////////////////////////// TGeoXtru* upendcapsupportshape[klayernumber]; TGeoVolume* upendcapsupport[klayernumber]; - char upendcapsupportname[30]; + char upendcapsupportname[100]; for(Int_t i=0; iDefinePolygon(knedges+3,xupvertex[i],yupvertex[i]); upendcapsupportshape[i]->DefineSection(0,0.); upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth); @@ -7181,10 +6831,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ //////////////////////////////////// TGeoXtru* downendcapsupportshape[klayernumber]; TGeoVolume* downendcapsupport[klayernumber]; - char downendcapsupportname[30]; + char downendcapsupportname[100]; for(Int_t i=0; iDefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]); if(i==0){ @@ -7208,10 +6858,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ TGeoPgon* endcapsupportmothershape[klayernumber]; TGeoVolume** endcapsupportmother; endcapsupportmother = new TGeoVolume*[klayernumber]; - char endcapsupportmothername[30]; + char endcapsupportmothername[100]; for(Int_t i=0; iDefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]); endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth, ydownvertex[i][0],yupvertex[i][1]); @@ -7260,10 +6910,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ // Setting TGeoPgon Volume for Mother Container /////////////////////////////////////////////// TGeoPgon* endcapsupportsystemshape[klayernumber]; - char endcapsupportsystemothername[30]; + char endcapsupportsystemothername[100]; for(Int_t i=0; iDefineSection(0,-(fgkEndCapCoverPlateWidth[1] - fgkEndCapCoverPlateWidth[0]),*radiusmin[i], (*radiusmax[i]*CosD(0.5*upedgeangle[i]) @@ -7332,7 +6982,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ for(Int_t j=0; jSetLineColor(9); - TGeoRotation* ssdcablepatchpanel3B26rot[3]; + TGeoRotation* ssdcablepatchpanel3B26rot[4]; for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation(); ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0); ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0] @@ -8112,10 +7762,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]; @@ -8169,7 +7819,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]; @@ -8183,7 +7833,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcablepatchpanel3RB24pconshape, fSSDCopper); ssdcablepatchpanel3RB24pcon->SetLineColor(9); - TGeoRotation* ssdcablepatchpanel3B24rot[3]; + TGeoRotation* ssdcablepatchpanel3B24rot[4]; for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation(); ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0); ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0] @@ -8202,10 +7852,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]; @@ -8294,37 +7944,48 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ return ssdcablesmother; } //////////////////////////////////////////////////////////////////////////////// -TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, - Double_t height, const char* shapename, Int_t isign) const{ +TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width, + Double_t height, const char* shapename, Int_t isign) const{ ///////////////////////////////////////////////////////////// // Method generating an Arb shape ///////////////////////////////////////////////////////////// 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; } /////////////////////////////////////////////////////////////////////////////// @@ -8377,7 +8038,7 @@ TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin, return arcshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const { +TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Screw Shape // radius[0]: outer radius @@ -8417,7 +8078,7 @@ TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumb return screwshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const { +TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Hole Shape // radius of the Hole @@ -8449,7 +8110,7 @@ TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Dou return holeshape; } //////////////////////////////////////////////////////////////////////////////// -TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{ +TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{ ///////////////////////////////////////////////////////////// // Given an axis specified by param, it gives the reflection of the point // respect to the axis @@ -8465,7 +8126,7 @@ TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) return reflectedvector; } //////////////////////////////////////////////////////////////////////////////// -TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct, +TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct, Double_t dx, Double_t dy, Double_t dz) const{ @@ -8485,11 +8146,11 @@ TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) { ///////////////////////////////////////////////////////////// // Method returning the Medium type ///////////////////////////////////////////////////////////// - char ch[30]; - sprintf(ch, "ITS_%s",mediumName); + char ch[100]; + snprintf(ch,100, "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; } //////////////////////////////////////////////////////////////////////////////// @@ -8519,6 +8180,7 @@ void AliITSv11GeometrySSD::CreateMaterials(){ //////////////////////////////// fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); + fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$"); /////////////////////////// // Stiffener Hybrid Wire /////////////////////////// @@ -8560,6 +8222,8 @@ void AliITSv11GeometrySSD::CreateMaterials(){ ///////////////////////////////////////////////////////////////////// fSSDAir = GetMedium("SDD AIR$"); fSSDCopper = GetMedium("COPPER$"); + fSSDSn = GetMedium("Sn$"); fCreateMaterials = kTRUE; } ///////////////////////////////////////////////////////////////////// +