for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
new TVector3((GetReflection(vertexposition[0][j],param))->X(),
(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];
/////////////////////////////////////////////////////////////
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]
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];
// 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];
/////////////////////////////////////////////////////////////
- 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);
// 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; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
- const Int_t kmothervertexnumber = 12;
- Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
- Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
- Double_t ssdchipcablesradius[kchipsystemnumber];
- Double_t ssdchipseparation = fgkSSDSensorLength
- - 2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth
- - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
- for(Int_t i=0; i<kchipsystemnumber; i++)
- ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
- - fgkSSDChipCablesHeight[0]
- - fgkSSDChipCablesHeight[1]);
- ///////////////////////
- // Setting the vertices
- ///////////////////////
- xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
- xmothervertex[0][1] = xmothervertex[0][0];
- xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
- + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
- xmothervertex[0][3] = xmothervertex[0][2];
- xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
- xmothervertex[0][5] = xmothervertex[0][4];
- xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
- xmothervertex[0][7] = xmothervertex[0][6];
- xmothervertex[0][8] = 0.0;
- xmothervertex[0][9] = xmothervertex[0][8];
- xmothervertex[0][10] = xmothervertex[0][4];
- xmothervertex[0][11] = xmothervertex[0][10];
- for(Int_t i=0; i<kmothervertexnumber; i++)
- xmothervertex[1][i] = xmothervertex[0][i];
- for(Int_t i=0; i<kchipsystemnumber; i++){
- ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
- - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
- ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
- ymothervertex[i][2] = ymothervertex[i][1];
- ymothervertex[i][3] = ymothervertex[i][0];
- ymothervertex[i][4] = ymothervertex[i][0];
- ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
- ymothervertex[i][6] = ymothervertex[i][5];
- ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
- ymothervertex[i][8] = ymothervertex[i][7];
- ymothervertex[i][9] = ymothervertex[i][5];
- ymothervertex[i][10] = ymothervertex[i][5];
- ymothervertex[i][11] = ymothervertex[i][4];
- }
- //////////////////////////////////////////////////////////
-// TGeoVolume* chipsystemother[kchipsystemnumber];
+
TGeoVolumeAssembly* chipsystemother[kchipsystemnumber];
const char* chipsytemothername[kchipsystemnumber] =
{"SSDChipSytemother1","SSDChipSytemother2"};
for(Int_t i=0; i<kchipsystemnumber; i++){
- chipsystemothershape[i]->DefinePolygon(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]);
}
/////////////////////////////////////////////////////////////
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
}
Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
{fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
- char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
+ const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
// Method generating Ladder Cable Volumes Assembly
/////////////////////////////////////////////////////////////
TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
- char laddercabletransname[30];
+ char laddercabletransname[100];
for(Int_t i=0; i<n; i++){
sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
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; i<kladdercableassemblynumber; i++){
sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
for(Int_t i=0; i<fgklayernumber; i++){
mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
- *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
+ * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
* TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
- mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
/ kssdlayladdernumber[i])));
theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
mountingsupportedgevector[i] = new TVector3();
- mountingsupportedgevector[i]->SetX(-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;
}
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; i<fgklayernumber; i++){
sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
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; i<fgklayernumber; i++){
///////////////////////////
// Mounting Block Down Vertex
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; i<fgklayernumber; i++){
////////////////////////////////////////////
for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
Double_t boxoriginup[fgklayernumber][2][3];
Double_t boxorigindown[fgklayernumber][2][3];
- char mountingblocksupportboxdownname[34];
- char mountingblocksupportboxupname[34];
+ char mountingblocksupportboxdownname[100];
+ char mountingblocksupportboxupname[100];
TGeoRotation* mountingblocksupportrot = new TGeoRotation();
mountingblocksupportrot->SetAngles(90.,180.,-90);
TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
TGeoXtru* upmotherladdersupportshape[fgklayernumber];
// TGeoVolume* upmotherladdersupport[fgklayernumber];
TGeoVolumeAssembly* upmotherladdersupport[fgklayernumber];
- char upmotheladdersupportname[30];
- char downmotheladdersupportname[30];
+ char upmotheladdersupportname[100];
+ char downmotheladdersupportname[100];
for(Int_t i=0; i<fgklayernumber; i++){
xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
- mountingsupportedge[i];
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;
/////////////////////
for(Int_t i=0; i<fgklayernumber; i++){
mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
- *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
+ *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
* TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
- mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
/ kssdlayladdernumber[i])));
////////////////////////////////////////////////////////////////////////////////
// Start Corrections 13/06/08
////////////////////////////////////////////////////////////////////////////////
- char lowerladderpconsupportname[30];
+ char lowerladderpconsupportname[100];
TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
TGeoVolume* lowerladderpconsupport[fgklayernumber];
Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
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);
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);
////////////////////////////////////
TGeoXtru* upendcapsupportshape[klayernumber];
TGeoVolume* upendcapsupport[klayernumber];
- char upendcapsupportname[30];
+ char upendcapsupportname[100];
for(Int_t i=0; i<klayernumber; i++){
upendcapsupportshape[i] = new TGeoXtru(2);
sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
////////////////////////////////////
TGeoXtru* downendcapsupportshape[klayernumber];
TGeoVolume* downendcapsupport[klayernumber];
- char downendcapsupportname[30];
+ char downendcapsupportname[100];
for(Int_t i=0; i<klayernumber; i++){
downendcapsupportshape[i] = new TGeoXtru(2);
sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
TGeoPgon* endcapsupportmothershape[klayernumber];
TGeoVolume** endcapsupportmother;
endcapsupportmother = new TGeoVolume*[klayernumber];
- char endcapsupportmothername[30];
+ char endcapsupportmothername[100];
for(Int_t i=0; i<klayernumber; i++){
endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
// Setting TGeoPgon Volume for Mother Container
///////////////////////////////////////////////
TGeoPgon* endcapsupportsystemshape[klayernumber];
- char endcapsupportsystemothername[30];
+ char endcapsupportsystemothername[100];
for(Int_t i=0; i<klayernumber; i++){
endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
ssdcablepatchpanel3RB26pcon->SetLineColor(9);
TGeoRotation* ssdcablepatchpanel3B26rot[3];
for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
- ssdcablepatchpanel3B26rot[0]->SetAngles(1.0,0.0,0.0);
+ ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
- + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
- ssdcablepatchpanel3B26rot[2]->SetAngles(181.0,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();
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]);
}
////////////////////////////////////////////////////////////////////////////////
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
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// Method returning the Medium type
/////////////////////////////////////////////////////////////
- char ch[30];
+ char ch[100];
sprintf(ch, "ITS_%s",mediumName);
TGeoMedium* medium = gGeoManager->GetMedium(ch);
if (! medium)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff