X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSv11GeometrySSD.cxx;h=0b221e73f3785c534b06449107e3506a4e819370;hb=b5113062351878fa479f7c1b3982556e2e0bdbe8;hp=62486d399fa8bb664aa2b308681420b2e7091205;hpb=99be538ebec999a933ca845c4ce13a2d5ee707eb;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx index 62486d399fa..0b221e73f37 100644 --- a/ITS/AliITSv11GeometrySSD.cxx +++ b/ITS/AliITSv11GeometrySSD.cxx @@ -38,12 +38,12 @@ #include "TGeoPcon.h" #include "TRotation.h" #include "AliITSv11GeometrySSD.h" -#include "Riostream.h" + ///////////////////////////////////////////////////////////////////////////////// // Names of the Sensitive Volumes of Layer 5 and Layer 6 ///////////////////////////////////////////////////////////////////////////////// -const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5"; -const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6"; +const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5"; +const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6"; ///////////////////////////////////////////////////////////////////////////////// //Parameters for SSD Geometry ///////////////////////////////////////////////////////////////////////////////// @@ -88,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) ///////////////////////////////////////////////////////////////////////////////// @@ -116,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 = @@ -160,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) ///////////////////////////////////////////////////////////////////////////////// @@ -317,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 = @@ -493,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; @@ -552,6 +553,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fSSDStiffenerConnectorMedium(), fSSDStiffener0603CapacitorMedium(), fSSDStiffener1812CapacitorMedium(), + fSSDStiffenerCapacitorCapMedium(), fSSDStiffenerHybridWireMedium(), fSSDKaptonFlexMedium(), fSSDAlTraceFlexMedium(), @@ -571,6 +573,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fSSDRohaCellCone(), fSSDAir(), fSSDCopper(), + fSSDSn(), fCreateMaterials(kFALSE), fTransformationMatrices(kFALSE), fBasicObjects(kFALSE), @@ -599,6 +602,7 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fColorPhynox(14), fColorSilicon(3), fColorAl(38), + fColorNiSn(40), fColorKapton(6), fColorPolyhamide(5), fColorStiffener(9), @@ -609,89 +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(){ /////////////////////////////////////////////////////////////////////// @@ -1006,14 +1001,14 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ 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)); - } + 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 ///////////////////////////////////////////////////////////// @@ -1081,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 ///////////////////////////////////////////////////////////// @@ -1159,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, @@ -1198,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], @@ -1426,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 /////////////////////////////////////////// @@ -1603,7 +1593,6 @@ void AliITSv11GeometrySSD::CreateTransformationMatrices(){ } delete endladdermountingblockrot; for(Int_t i=0; iSetLineColor(fColorSilicon); ssdsensorsensitiveLay6->SetLineColor(fColorSilicon); TGeoBBox* ssdsensorinsensitiveshape[2]; @@ -1941,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]; @@ -2023,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 ///////////////////////////////////////////////////////////// @@ -2069,9 +2058,9 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ /////////////////////////////////////// TVector3** vertexposition = new TVector3*[kvertexnumber]; - 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)); + 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(), @@ -2083,8 +2072,8 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){ for(Int_t i=0; iDefinePolygon(8,xmothervertex[i],ymothervertex[i]); shape->DefineSection(0,-0.5*fgkSSDStiffenerLength); @@ -2311,13 +2295,35 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ // Capacitor 0603-2200 nF /////////////////////////// const Int_t knapacitor0603number = 5; + TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape", + 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength, + 0.5*fgkSSDCapacitor0603Width, + 0.5*fgkSSDCapacitor0603Height); + TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape, + fSSDAir); + TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape", 0.5*fgkSSDCapacitor0603Length, - 0.5*(fgkSSDCapacitor0603Width), + 0.5*fgkSSDCapacitor0603Width, 0.5*fgkSSDCapacitor0603Height); TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape, fSSDStiffener0603CapacitorMedium); capacitor0603->SetLineColor(fColorAl); + TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.); + capacitor0603mother->AddNode(capacitor0603,1,cap0603trans); + + TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape", + 0.5*fgkSSDCapacitor0603CapLength, + 0.5*fgkSSDCapacitor0603Width, + 0.5*fgkSSDCapacitor0603Height); + TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape, + fSSDStiffenerCapacitorCapMedium); + capacitor0603cap->SetLineColor(fColorNiSn); + TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.); + capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1); + TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.); + capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2); + TGeoVolume* ssdchip = GetSSDChip(); @@ -2328,7 +2334,7 @@ TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ for(Int_t j=0; jAddNode(ssdstiffener,1,hybridmotherrotInv); for(Int_t k=1; kAddNode(capacitor0603,k, + ssdhybridmother[i][j]->AddNode(capacitor0603mother,k, new TGeoCombiTrans("", -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width), -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height), @@ -2394,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 @@ -2440,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 //////////////////////////// @@ -2482,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, @@ -2514,76 +2550,24 @@ 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* ssdcoolingblock = GetSSDCoolingBlock(30); ///////////////////////////////////////////////////////////// @@ -3021,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]; @@ -3375,12 +3359,10 @@ void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&ca 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((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans); if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); @@ -3715,7 +3693,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladderc TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans", (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0], fgkSSDLadderCableWidth-fgkSSDFlexWidth[0], - (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])); + (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])); laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans); return laddercable; } @@ -3725,14 +3703,14 @@ TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssden // Main method generating Ladder Cable bundles containing n cables /////////////////////////////////////////////////////////////////// Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0]; - Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])}; - TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]),cableOrig); + 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 laddercable; } @@ -3748,7 +3726,7 @@ TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdend char laddercableassemblyname[100]; TList* laddercableassemblylist = new TList(); for(Int_t i=0; iAddNode(laddercableassembly,i+1,i==0 ? NULL : new TGeoCombiTrans((n-1) @@ -3845,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], @@ -3917,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]; @@ -4118,6 +4096,7 @@ void AliITSv11GeometrySSD::SetLadder(){ - fgkSSDModuleStiffenerPosition[1] - fgkSSDStiffenerWidth) + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection; + TList* laddercableassemblylist[4]; const Int_t kendladdercablesnumber = 4; TGeoRotation *laddercablerot = new TGeoRotation(); @@ -4303,11 +4282,11 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ 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] @@ -4376,7 +4355,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ // Mounting Block Down Vertex /////////////////////////// mountingblockpiecedownshape[i] = new TGeoXtru(2); - sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5); + snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5); mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]; mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i] + fgkMountingBlockSupportDownHeight @@ -4412,7 +4391,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ // 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] @@ -4484,7 +4463,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ 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); @@ -4513,7 +4492,7 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ 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); @@ -4567,8 +4546,8 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ xmothervertex[i][7] = xmothervertex[i][6]; ymothervertex[i][7] = ymothervertex[i][0]; - sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5); - sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5); + snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5); + snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5); downmotherladdersupportshape[i] = new TGeoXtru(2); downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]); @@ -4655,14 +4634,14 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ // Adding the Volumes to Mother Volume /////////////////////////////////////// for(Int_t j=0; j<2; j++){ - sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1); - sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1); - mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname, - mountingblocksupportboxdownshape[i][j], - fSSDCarbonFiberMedium); - mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname, - mountingblocksupportboxupshape[i][j], - fSSDCarbonFiberMedium); + snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1); + snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1); + mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname, + mountingblocksupportboxdownshape[i][j], + fSSDCarbonFiberMedium); + mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname, + mountingblocksupportboxupshape[i][j], + fSSDCarbonFiberMedium); mountingblocksupportboxdown[i][j]->SetLineColor(9); mountingblocksupportboxup[i][j]->SetLineColor(9); for(Int_t k=0; k<2; k++){ @@ -4834,7 +4813,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j, lowerladderpconezsection[j],lowerladderpconradiusmin[i], lowerladderpconradiusmax[i]); - sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5); + snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5); lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl); lowerladderpconsupport[i]->SetLineColor(fColorAl); (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1); @@ -5272,6 +5251,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ mothercoverplate->AddNode(holecontour[0],2,holecontourtrans); mothercoverplate->AddNode(holecontour[1],1); mothercoverplate->AddNode(contour,1); + + for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++) + delete [] endcapcoverplatesmallholetrans[i]; + delete [] endcapcoverplatesmallholetrans; ///////////////////////////////// return mothercoverplate; } @@ -5293,30 +5276,30 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ 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); @@ -5757,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 { @@ -6813,7 +6797,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ 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); @@ -6850,7 +6834,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ char downendcapsupportname[100]; for(Int_t i=0; iDefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]); if(i==0){ @@ -6877,7 +6861,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ 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]); @@ -6929,7 +6913,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ char endcapsupportsystemothername[100]; for(Int_t i=0; iDefineSection(0,-(fgkEndCapCoverPlateWidth[1] - fgkEndCapCoverPlateWidth[0]),*radiusmin[i], (*radiusmax[i]*CosD(0.5*upedgeangle[i]) @@ -7737,7 +7721,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ Double_t ssdcablepatchpanel3BB26radiusmin[2]; Double_t ssdcablepatchpanel3BB26radiusmax[2]; Double_t ssdcablepatchpanel3RB26zsection[2]; - ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8; + ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8+0.003;//Avoid small overlap with SPDshieldring; ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0] + fgkSSDCablesLay5RightSideHeight + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight; @@ -7757,7 +7741,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26", ssdcablepatchpanel3RB26pconshape,fSSDCopper); ssdcablepatchpanel3RB26pcon->SetLineColor(9); - TGeoRotation* ssdcablepatchpanel3B26rot[3]; + TGeoRotation* ssdcablepatchpanel3B26rot[4]; for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation(); ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0); ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0] @@ -7849,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] @@ -7960,7 +7944,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){ return ssdcablesmother; } //////////////////////////////////////////////////////////////////////////////// -TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, +TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width, Double_t height, const char* shapename, Int_t isign) const{ ///////////////////////////////////////////////////////////// // Method generating an Arb shape @@ -8054,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 @@ -8094,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 @@ -8126,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 @@ -8142,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{ @@ -8163,7 +8147,7 @@ TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) { // Method returning the Medium type ///////////////////////////////////////////////////////////// char ch[100]; - sprintf(ch, "ITS_%s",mediumName); + snprintf(ch,100, "ITS_%s",mediumName); TGeoMedium* medium = gGeoManager->GetMedium(ch); if (! medium) AliError(Form("medium %s not found !\n", mediumName)); @@ -8196,6 +8180,7 @@ void AliITSv11GeometrySSD::CreateMaterials(){ //////////////////////////////// fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); + fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$"); /////////////////////////// // Stiffener Hybrid Wire /////////////////////////// @@ -8237,6 +8222,8 @@ void AliITSv11GeometrySSD::CreateMaterials(){ ///////////////////////////////////////////////////////////////////// fSSDAir = GetMedium("SDD AIR$"); fSSDCopper = GetMedium("COPPER$"); + fSSDSn = GetMedium("Sn$"); fCreateMaterials = kTRUE; } ///////////////////////////////////////////////////////////////////// +