X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySSD.cxx;h=d78d926527e5c2bc7c45054d6e5ea3e438c14ceb;hb=90ae20c9a7d507ee8464f779b36b3e64e6b1752e;hp=f649c7cff85017826ea2078e9e04d0c30edd18ef;hpb=ca86fdb4728c96a7fa4901b6d98aca1ee07fba28;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx index f649c7cff85..d78d926527e 100644 --- a/ITS/AliITSv11GeometrySSD.cxx +++ b/ITS/AliITSv11GeometrySSD.cxx @@ -29,6 +29,7 @@ #include "TList.h" #include "TGeoMatrix.h" #include "TGeoCompositeShape.h" +#include "TGeoBoolNode.h" #include "TGeoTube.h" #include "TGeoBBox.h" #include "TGeoXtru.h" @@ -48,9 +49,8 @@ const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6"; // Variable for Vertical Disalignement of Modules ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm; -//const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 1.*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment2 = 0.2*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Layer5 (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// @@ -174,8 +174,8 @@ const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength = const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth = 2.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] = - { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment2, - 5.180*fgkmm-fgkSSDModuleVerticalDisalignment2}; + { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment, + 5.220*fgkmm-fgkSSDModuleVerticalDisalignment}; //const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] = // { 4.520*fgkmm, 5.130*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = @@ -207,12 +207,12 @@ const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] = { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor - (fgkSSDSensorSideSupportHeight[1] - fgkSSDSensorSideSupportHeight[0]) - - fgkSSDModuleVerticalDisalignment2 + - fgkSSDModuleVerticalDisalignment - fgkSSDCoolingBlockHoleCenter - fgkSSDStiffenerHeight - fgkSSDChipHeight-fgkSSDSensorHeight, fgkSSDModuleCoolingBlockToSensor - - fgkSSDModuleVerticalDisalignment2 + - fgkSSDModuleVerticalDisalignment - fgkSSDCoolingBlockHoleCenter - fgkSSDStiffenerHeight - fgkSSDChipHeight-fgkSSDSensorHeight}; @@ -258,6 +258,7 @@ const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength ///////////////////////////////////////////////////////////////////////////////// // Carbon Fiber Lower Support Parameters (lengths are in mm) ///////////////////////////////////////////////////////////////////////////////// +const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth = 0.950*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght @@ -364,25 +365,21 @@ const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDL - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportDownHeight, fgkSSDLay6RadiusMin - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportDownHeight}; const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportRadius[0], fgkSSDLay6RadiusMax - fgkSSDMountingBlockHeight[1] + 0.5*fgkCoolingTubeSupportHeight + fgkSSDModuleCoolingBlockToSensor - + fgkSSDModuleVerticalDisalignment - fgkMountingBlockSupportRadius[1]}; const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm; @@ -1198,7 +1195,7 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ - fgkSSDSensorCenterSupportThickness[0]), - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight - - fgkSSDModuleVerticalDisalignment2)); + - fgkSSDModuleVerticalDisalignment)); fhybridmatrix = new TGeoHMatrix(); for(Int_t i=0; iMultiplyLeft(localhybridtrans[i]); ///////////////////////////////////////////////////////////// @@ -1262,7 +1259,8 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle * TMath::DegToRad()*ssdflexradiusmax - fgkSSDFlexLength[2]-TMath::Pi() - * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0] + - 0.1*fgkSSDFlexFullLength; Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle) + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle) + fgkSSDFlexLength[2]; @@ -1571,25 +1569,19 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ TGeoTranslation* localssdsensortrans[2]; for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation(); localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, - - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + fgkCarbonFiberJunctionWidth + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ, 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight - - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment + - fgkSSDModuleCoolingBlockToSensor + (fgkSSDSensorSideSupportHeight[1] - - fgkSSDSensorSideSupportHeight[0]) - + 0.5*fgkSSDModuleVerticalDisalignment2); + - fgkSSDSensorSideSupportHeight[0])); localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, - - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ - fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth - + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth - - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength - - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + fgkCarbonFiberJunctionWidth + - fgkCarbonFiberLowerSupportWidth + - fgkLowerSupportToSensorZ, 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight - -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment - + 0.5*fgkSSDModuleVerticalDisalignment2); + -fgkSSDModuleCoolingBlockToSensor); for(Int_t i=0; i<2; i++) localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i], *localssdsensorrot); @@ -2026,9 +2018,9 @@ TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){ for(Int_t j=0; jX(), (GetReflection(vertexposition[0][j],param))->Y()); - char* carbonfibersupportshapename[kshapesnumber] = + const char* carbonfibersupportshapename[kshapesnumber] = {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"}; - char* carbonfibersupportname[kshapesnumber] = + const char* carbonfibersupportname[kshapesnumber] = {"CarbonFiberSupport1","CarbonFiberSupport2"}; TGeoArb8* carbonfibersupportshape[kshapesnumber]; TGeoVolume* carbonfibersupport[kshapesnumber]; @@ -2065,8 +2057,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] @@ -2127,9 +2119,9 @@ TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){ vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]); vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength, fgkCarbonFiberLowerSupportVolumePosition[1]); - char* carbonfiberlowersupportshapename[kshapesnumber] = + const char* carbonfiberlowersupportshapename[kshapesnumber] = {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"}; - char* carbonfiberlowersupportname[kshapesnumber] = + const char* carbonfiberlowersupportname[kshapesnumber] = {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"}; TGeoArb8* carbonfiberlowersupportshape[kshapesnumber]; TGeoVolume* carbonfiberlowersupport[kshapesnumber]; @@ -2350,10 +2342,10 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ // 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]; ///////////////////////////////////////////////////////////// @@ -2460,7 +2452,7 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ const Int_t knapacitor0603number = 5; TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape", 0.5*fgkSSDCapacitor0603Length, - 0.5*(fgkSSDCapacitor0603Width-fgkSSDTolerance), + 0.5*(fgkSSDCapacitor0603Width), 0.5*fgkSSDCapacitor0603Height); TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape, fSSDStiffener0603CapacitorMedium); @@ -2469,12 +2461,12 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ for(Int_t j=0; jAddNode(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(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); @@ -2589,8 +2581,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); @@ -2730,7 +2722,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){ // Adding Cooling block to mother volume ///////////////////////////////////////////////////////////// for(Int_t i=0; iAddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]); + coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]); coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]); coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]); } @@ -2870,7 +2862,8 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){ Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle * TMath::DegToRad()*ssdflexradiusmax - fgkSSDFlexLength[2]-TMath::Pi() - * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0] + - 0.1*fgkSSDFlexFullLength; const Int_t knedges = 20; const Int_t karcnumber = 2; TVector3* vertexposition[karcnumber*(knedges+1)]; @@ -2973,8 +2966,9 @@ for(Int_t i=0; iDefineSection(0,-0.5*fgkSSDFlexWidth[0]); ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]); - TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother", - ssdendflexmothershape,fSSDAir); +// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother", +// ssdendflexmothershape,fSSDAir); + TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother"); ////////////////////////////////////// // End Flex TGeoXtru Layer Definition ////////////////////////////////////// @@ -3036,8 +3030,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ - fgkSSDMountingBlockScrewHoleRadius[0]; xvertex[7] = xvertex[6]; yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor - + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0] - - fgkSSDModuleVerticalDisalignment; + + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]; yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0]; yvertex[2] = yvertex[1]; yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1]; @@ -3224,8 +3217,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]); xmothervertex[9] = xmothervertex[8]; ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor - + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0] - - fgkSSDModuleVerticalDisalignment; + + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]; ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness; ymothervertex[2] = ymothervertex[1]; ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1] @@ -3300,7 +3292,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ Int_t edgesnumber[2] = {50,6}; Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]), +0.5*(ymothervertex[3]-ymothervertex[2])}; - TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section); + TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section); TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl); clipscrew->SetLineColor(12); TGeoRotation* screwrot = new TGeoRotation(); @@ -3336,18 +3328,19 @@ TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{ // Ladder Cooling Tubes coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1] - - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)); + - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth) + -0.5*fgkSSDTolerance); coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, coolingtubeshape[0][0]->GetDz()); coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, 0.5*(fgkSSDModuleStiffenerPosition[1] - - fgkSSDSensorOverlap)); + - 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])); + 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDTolerance)); coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - coolingtubeshape[2][0]->GetDz()); + coolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance); // End Ladder Cooling Tubes TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber]; for(Int_t i=0; iGetDz()); + 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()); + endladdercoolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance); endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, 0.50 * (fgkMountingBlockToSensorSupport - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth) @@ -3380,11 +3373,11 @@ TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{ - fgkEndLadderMountingBlockPosition[1] - fgkCoolingTubeSupportWidth-fgkSSDTolerance)); endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, - endladdercoolingtubeshape[3][0]->GetDz()); + 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()); + endladdercoolingtubeshape[4][0]->GetDz()-0.5*fgkSSDTolerance); // Ladder Cooling Tubes TGeoVolume** coolingtube[fgkcoolingtubenumber]; for(Int_t i=0; iSetLineColor(fColorPhynox); endladdercoolingtube[i][1]->SetLineColor(fColorWater); } + ///////////////////////////////////////////////////////////// // Virtual Volume containing Cooling Tubes ///////////////////////////////////////////////////////////// @@ -3704,7 +3698,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, +fgkSSDChipCablesWidth[2]); Double_t dy = fgkSSDChipCablesLength[1]; Double_t dz = SSDChipCablesHeigth; - TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin); + new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin); TGeoVolumeAssembly* ssdchipcablesmother = new TGeoVolumeAssembly("SSDChipCablesMother"); // TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother", // ssdchipcablesmotherbox,fSSDAir); @@ -3749,69 +3743,11 @@ TList* AliITSv11GeometrySSD::GetSSDChipSystem(){ // const Int_t knedges = 20; const Int_t knedges = 5; const Int_t kchipsystemnumber = 2; - ///////////////////////////////////////////////////////////// - // Mother Volume containing SSDChipSystem - ///////////////////////////////////////////////////////////// - TGeoXtru* chipsystemothershape[kchipsystemnumber]; - 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]); } ///////////////////////////////////////////////////////////// @@ -3855,13 +3791,14 @@ TList* AliITSv11GeometrySSD::GetSSDChipSystem(){ delete ssdchipcablesrot[i][j]; delete ssdchipcablestrans[i][j]; } - delete ssdchipcablesrot[i]; - delete ssdchipcablestrans[i]; + delete [] ssdchipcablesrot[i]; + delete [] ssdchipcablestrans[i]; } ///////////////////////////////////////////////////////////// return ssdchipsystemlist; } -/////////////////////////////////////////////////////////////////////////////// + +//_____________________________________________________________________________ TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{ ///////////////////////////////////////////////////////////// // SSD Chip Assembly Generation @@ -3933,8 +3870,9 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{ xmothervertex,ymothervertex); ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight); ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight); - TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer", - ssdchipmothershape,fSSDAir); +// TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer", +// ssdchipmothershape,fSSDAir); + TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer"); ///////////////////////////////////////////////////////////// for(Int_t i=0; iAddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, @@ -4136,7 +4074,7 @@ TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdend const Int_t kladdercableassemblynumber = 2; TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength); TGeoVolume* ladderCable[kladdercableassemblynumber]; - char laddercableassemblyname[30]; + char laddercableassemblyname[100]; TList* laddercableassemblylist = new TList(); for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xmothervertex[i], - ymothervertex[i]); - laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]); - laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth + leftladdershape[i] = new TGeoXtru(2); + centersensorladdershape[i] = new TGeoXtru(2); + rightladdershape[i] = new TGeoXtru(2); + } + ////////////////////////////////////// + // Setting the names for shapes + ////////////////////////////////////// + leftladdershape[0]->SetName("Lay5LeftLadderSegmentContainer"); + leftladdershape[1]->SetName("Lay6LeftLadderSegmentContainer"); + centersensorladdershape[0]->SetName("Lay5CenterSensorContainer"); + centersensorladdershape[1]->SetName("Lay6CenterSensorContainer"); + rightladdershape[0]->SetName("Lay5RightLadderSegmentContainer"); + rightladdershape[1]->SetName("Lay6RightLadderSegmentContainer"); + ////////////////////////////////////// + Double_t xleftladdervertex[fgkladdernumber][kmothervertexnumber]; + Double_t yleftladdervertex[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,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]); - fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir); - fladder[i]->SetLineColor(4); - } + } + 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); + } /////////////////////////////////////////////////////////////////////////// if(!fCreateMaterials) CreateMaterials(); if(!fTransformationMatrices) CreateTransformationMatrices(); @@ -4408,8 +4420,8 @@ void AliITSv11GeometrySSD::SetLadder(){ laddercableassemblylist[j] = GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1], ssdendladdercablelength[j]); -// fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1), -// j<2?1:2,fladdercablematrix[i][j]); + fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1), + j<2?1:2,fladdercablematrix[i][j]); } } //////////////////////////////////////////////////////////////////////////////// @@ -4490,17 +4502,17 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ 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; } @@ -4579,10 +4591,10 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ TGeoVolume* centermountingblocksupport[fgklayernumber]; TGeoVolume* sideladdersupportpiece[fgklayernumber]; TGeoVolume* centerladdersupportpiece[fgklayernumber]; - char sidemountingblockname[40]; - char centermountingblockname[40]; - char sideladdersupportpiecename[40]; - char centerladdersupportpiecename[40]; + char sidemountingblockname[100]; + char centermountingblockname[100]; + char sideladdersupportpiecename[100]; + char centerladdersupportpiecename[100]; for(Int_t i=0; iSetAngles(90.,180.,-90); TGeoRotation* globalrefladdersupportrot = new TGeoRotation(); @@ -4820,9 +4830,10 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ TGeoXtru* downmotherladdersupportshape[fgklayernumber]; TGeoVolume* downmotherladdersupport[fgklayernumber]; TGeoXtru* upmotherladdersupportshape[fgklayernumber]; - TGeoVolume* upmotherladdersupport[fgklayernumber]; - char upmotheladdersupportname[30]; - char downmotheladdersupportname[30]; +// TGeoVolume* upmotherladdersupport[fgklayernumber]; + TGeoVolumeAssembly* upmotherladdersupport[fgklayernumber]; + char upmotheladdersupportname[100]; + char downmotheladdersupportname[100]; for(Int_t i=0; iSetLineColor(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++){ @@ -4946,11 +4956,11 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ 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(); @@ -4976,14 +4986,14 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ delete [] xcenterlowervertex[i]; delete [] ycenterlowervertex[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; ///////////////////// @@ -5008,7 +5018,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ for(Int_t i=0; iSetLineColor(6); - TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius, + TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius, nendcapcoverplateholedges,holesection); TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole", endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium); @@ -5248,7 +5258,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ fSSDAlCoolBlockMedium); endcapfillingbox->SetLineColor(6); //////////////////////////// - // Contour Xtru Definition + // Contour shape Definition //////////////////////////// const Int_t kcontourvertexnumber = 10; Double_t xcontourvertex[kcontourvertexnumber]; @@ -5278,17 +5288,112 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ + fgkEndCapCoverPlateSmallHoleRadius; ycontourvertex[8] = ycontourvertex[7]; ycontourvertex[9] = ycontourvertex[0]; - TGeoXtru* contourshape = new TGeoXtru(2); - contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex); - contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); + + Double_t xboxin, dxboxin, yboxin, dyboxin; + Double_t xboxout, dxboxout, yboxout, dyboxout; + Double_t coordmin, coordmax; + coordmin = -fgkEndCapCoverPlateLength[0]; + coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2] + - (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2]); + coordmax = (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = -fgkEndCapCoverPlateSmallHoleRadius; + coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = -fgkEndCapCoverPlateSmallHoleRadius; + coordmax = (kendcapcoverplatesmallholenumber[1]-1) + * fgkEndCapCoverPlateSmallHoleSeparation[2] + + fgkEndCapCoverPlateSmallHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin->RegisterYourself(); + TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape", + "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn"); + TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape, fSSDAlCoolBlockMedium); contour->SetLineColor(6); ///////////////////////////// - // Hole Contour Xtru Definition + // Hole Contour Shape Definition //////////////////////////// - const Int_t kholecontourvertexnumber = 10; + coordmin = xcontourvertex[0]; + coordmax = coordmin+fgkEndCapCoverPlateLength[2]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[1]; + coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius);; + coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout1->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin1->RegisterYourself(); + TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1", + "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1"); + + + coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]; + coordmax = coordmin+fgkEndCapCoverPlateLength[2]; + xboxout = 0.5*(coordmin+coordmax); + dxboxout = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0]); + coordmax = ycontourvertex[0]; + yboxout = 0.5*(coordmin+coordmax); + dyboxout = 0.5*(coordmax-coordmin); + coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius; + xboxin = 0.5*(coordmin+coordmax); + dxboxin = 0.5*(coordmax-coordmin); + coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1] + - fgkEndCapCoverPlateWidth[0] + - 2.*fgkEndCapCoverPlateBigHoleRadius); + coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius; + yboxin = 0.5*(coordmin+coordmax); + dyboxin = 0.5*(coordmax-coordmin); + new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness); + TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2", + xboxout, yboxout, 0.); + trendCapCoverPlateContourboxout2->RegisterYourself(); + new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01); + TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2", + xboxin, yboxin, 0.); + trendCapCoverPlateContourboxin2->RegisterYourself(); + TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2", + "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2"); + +// const Int_t kholecontourvertexnumber = 10; + Double_t xholecontourvertex[2][kcontourvertexnumber]; Double_t yholecontourvertex[2][kcontourvertexnumber]; xholecontourvertex[0][0] = xcontourvertex[0]; @@ -5345,24 +5450,11 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ yholecontourvertex[1][8] = yholecontourvertex[1][7]; yholecontourvertex[1][9] = yholecontourvertex[1][0]; - TGeoXtru* holecontourshape[2]; - holecontourshape[0] = new TGeoXtru(2); - holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0], - yholecontourvertex[0]); - holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); - - holecontourshape[1] = new TGeoXtru(2); - holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1], - yholecontourvertex[1]); - holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness); - holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness); - TGeoVolume* holecontour[2]; - holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0], + holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1, fSSDAlCoolBlockMedium); holecontour[0]->SetLineColor(6); - holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1], + holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2, fSSDAlCoolBlockMedium); holecontour[1]->SetLineColor(6); TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3] @@ -5468,14 +5560,14 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ TGeoVolume* endcapcoolingtubetorus[5]; TGeoTube* endcapcoolingtubeshape[4]; TGeoVolume* endcapcoolingtube[4]; - char endcapcoolingtubetorusname[30]; - char endcapcoolingtubename[30]; + char endcapcoolingtubetorusname[100]; + char endcapcoolingtubename[100]; TGeoTorus* endcapcoolingwatertubetorushape[5]; TGeoVolume* endcapcoolingwatertubetorus[5]; TGeoTube* endcapcoolingwatertubeshape[4]; TGeoVolume* endcapcoolingwatertube[4]; - char endcapcoolingwatertubetorusname[30]; - char endcapcoolingwatertubename[30]; + char endcapcoolingwatertubetorusname[100]; + char endcapcoolingwatertubename[100]; for(Int_t i=0; i<5; i++){ sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1); sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1); @@ -5842,10 +5934,19 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]; yvertex[13] = yvertex[12]; yvertex[14] = yvertex[6]; - TGeoXtru* endcapsidecovershape = new TGeoXtru(2); - endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex); - endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness); - endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness); + TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2); + endcapsidecovershapeout->SetName("endcapsidecovershapeout"); + endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex); + endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness); + endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness); + TGeoXtru* endcapsidecovershapein = new TGeoXtru(2); + endcapsidecovershapein->SetName("endcapsidecovershapein"); + endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]); + endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01); + endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01); + + + TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein"); TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover", endcapsidecovershape,fSSDCoolingTubePhynox); endcapsidecover->SetLineColor(fColorPhynox); @@ -6650,7 +6751,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness, fgkEndCapCoverPlateThickness + fgkEndCapCoolingTubeRadiusMax}; - TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius, + TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius, screwcoverplatedgesnumber, screwcoverplatesection); TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate", @@ -6923,14 +7024,13 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t radiusmax, Double_t width, Int_t ncables, - char* volname){ + const char* volname){ ///////////////////////////////////////////////////////////// // Generating EndCap High Voltage Tubes ///////////////////////////////////////////////////////////// Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin; - Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.) - + TMath::Power(radiusmax,2.) - - TMath::Power(radiusmin,2.)); + Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin)); + TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width); TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius, effectiveouteradius,0.5*width); @@ -6986,7 +7086,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ //////////////////////////////////// TGeoXtru* upendcapsupportshape[klayernumber]; TGeoVolume* upendcapsupport[klayernumber]; - char upendcapsupportname[30]; + char upendcapsupportname[100]; for(Int_t i=0; iSetAngles(0.0,0.0,0.0); ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0] - + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0); + + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0); ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0); ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0] - + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0); + + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0); for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]); //////////////////////////////////// //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity(); @@ -8027,10 +8127,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ ssdcablepatchpanel3RB24pcon->SetLineColor(9); TGeoRotation* ssdcablepatchpanel3B24rot[3]; for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation(); - ssdcablepatchpanel3B24rot[0]->SetAngles(0.0,0.0,0.0); + ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0); ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0] + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0); - ssdcablepatchpanel3B24rot[2]->SetAngles(180.0,0.0,0.0); + ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0); ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0] + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0); for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]); @@ -8137,7 +8237,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ } //////////////////////////////////////////////////////////////////////////////// TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, - Double_t height, char* shapename, Int_t isign) const{ + Double_t height, const char* shapename, Int_t isign) const{ ///////////////////////////////////////////////////////////// // Method generating an Arb shape ///////////////////////////////////////////////////////////// @@ -8219,7 +8319,7 @@ TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin, return arcshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const { +TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Screw Shape // radius[0]: outer radius @@ -8233,52 +8333,59 @@ TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumbe Double_t inradius = radius[1]; Int_t outvertexnumber = edgesnumber[0]; Int_t invertexnumber = edgesnumber[1]; - Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2]; - Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2]; - for(Int_t i=0; iDefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex); - screwshape->DefineSection(0,section[0]); - screwshape->DefineSection(1,section[1]); + TGeoXtru* screwshapeout = new TGeoXtru(2); + screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex); + screwshapeout->DefineSection(0,section[0]); + screwshapeout->DefineSection(1,section[1]); + TGeoXtru* screwshapein = new TGeoXtru(2); + screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]); + screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z + screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it + TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein); + TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode); + delete [] xscrewvertex; delete [] yscrewvertex; return screwshape; } //////////////////////////////////////////////////////////////////////////////// -TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const { +TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const { /////////////////////////////////////////////////////////////////////// // Method Generating the Hole Shape // radius of the Hole // nedges: number of edges to approximate the circle /////////////////////////////////////////////////////////////////////// - Int_t vertexnumber = nedges+6; - Double_t* xholevertex = new Double_t[vertexnumber]; - Double_t* yholevertex = new Double_t[vertexnumber]; - xholevertex[0] = radius; - xholevertex[1] = xholevertex[0]; - xholevertex[2] = -xholevertex[1]; - xholevertex[3] = xholevertex[2]; - xholevertex[4] = xholevertex[0]; - yholevertex[0] = 0.; - yholevertex[1] = -radius; - yholevertex[2] = yholevertex[1]; - yholevertex[3] = -yholevertex[1]; - yholevertex[4] = yholevertex[3]; - for(Int_t i=0; i TGeoShape::Tolerance()) { + tr = new TGeoTranslation(0.,0.,z); + tr->RegisterYourself(); + } + TGeoBBox *box = new TGeoBBox("",radius,radius,dz); + for(Int_t i=0; iDefinePolygon(vertexnumber,xholevertex,yholevertex); - holeshape->DefineSection(0,section[0]); - holeshape->DefineSection(1,section[1]); + TGeoXtru* holeshapeout = new TGeoXtru(2); + holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex); + holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z + holeshapeout->DefineSection(1,section[1]+0.01); + TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr); + TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode); + delete [] xholevertex; delete [] yholevertex; return holeshape; @@ -8320,7 +8427,7 @@ TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) { ///////////////////////////////////////////////////////////// // Method returning the Medium type ///////////////////////////////////////////////////////////// - char ch[30]; + char ch[100]; sprintf(ch, "ITS_%s",mediumName); TGeoMedium* medium = gGeoManager->GetMedium(ch); if (! medium)