#include "TGeoPcon.h"
#include "TRotation.h"
#include "AliITSv11GeometrySSD.h"
+#include "Riostream.h"
/////////////////////////////////////////////////////////////////////////////////
// Names of the Sensitive Volumes of Layer 5 and Layer 6
/////////////////////////////////////////////////////////////////////////////////
// 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;
+// For ladders:
+const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.2*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
// Layer5 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
2.000*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
- { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment2,
- 5.220*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] =
{ 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
- (fgkSSDSensorSideSupportHeight[1]
- fgkSSDSensorSideSupportHeight[0])
- - fgkSSDModuleVerticalDisalignment2
+ - fgkSSDModuleVerticalDisalignment
- fgkSSDCoolingBlockHoleCenter
- fgkSSDStiffenerHeight
- fgkSSDChipHeight-fgkSSDSensorHeight,
fgkSSDModuleCoolingBlockToSensor
- - fgkSSDModuleVerticalDisalignment2
+ - fgkSSDModuleVerticalDisalignment
- fgkSSDCoolingBlockHoleCenter
- fgkSSDStiffenerHeight
- fgkSSDChipHeight-fgkSSDSensorHeight};
- 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;
- fgkSSDSensorCenterSupportThickness[0]),
- (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
- fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
- - fgkSSDModuleVerticalDisalignment2));
+ - fgkSSDModuleVerticalDisalignment));
fhybridmatrix = new TGeoHMatrix();
for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
/////////////////////////////////////////////////////////////
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];
- 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,
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);
Double_t* param = new Double_t[4];
param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
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] =
+ new TVector3((GetReflection(vertexposition[0][j],param))->X(),
+ (GetReflection(vertexposition[0][j],param))->Y());
+ const char* carbonfibersupportshapename[kshapesnumber] =
{"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
- char* carbonfibersupportname[kshapesnumber] =
+ const char* carbonfibersupportname[kshapesnumber] =
{"CarbonFiberSupport1","CarbonFiberSupport2"};
TGeoArb8* carbonfibersupportshape[kshapesnumber];
TGeoVolume* carbonfibersupport[kshapesnumber];
/////////////////////////////////////////////////////////////
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);
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)];
xmothervertex,ymothervertex);
ssdendflexmothershape->DefineSection(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
//////////////////////////////////////
- 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];
- fgkSSDMountingBlockHeight[0];
yvertex[6] = yvertex[5];
yvertex[7] = yvertex[0];
+
///////////////////////////////////////////////////////////////////////
// TGeoXTru Volume definition for Mounting Block Part
///////////////////////////////////////////////////////////////////////
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]
ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
ymothervertex[8] = ymothervertex[7];
ymothervertex[9] = ymothervertex[0];
+
///////////////////////////////////////////////////////////////////////
// TGeoXTru Volume definition for Mounting Block Clip Part
///////////////////////////////////////////////////////////////////////
// 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; i<fgkendladdercoolingtubenumber; i++)
+ fgkendladdercoolingsupportdistance[1]
- fgkCoolingTubeSupportWidth-fgkSSDTolerance));
endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[1][0]->GetDz());
+ 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)
- 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; i<fgkcoolingtubenumber; i++) coolingtube[i] =
endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
endladdercoolingtube[i][1]->SetLineColor(fColorWater);
}
+
/////////////////////////////////////////////////////////////
// Virtual Volume containing Cooling Tubes
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
delete [] vertexposition;
- delete xvertexpoints;
- delete yvertexpoints;
+ delete [] xvertexpoints;
+ delete [] yvertexpoints;
/////////////////////////////////////////////////////////////
return ssdcoolingblock;
}
// 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
/////////////////////////////////////////
// LadderSegmentBBox Volume
/////////////////////////////////////////
- TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
+ static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
+
+
+ const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
+ {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
+ static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
+
+ static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
+ new TGeoTranslation("LadderCableSegmentBBoxTrans1",
+ 0.5*fgkSSDFlexWidth[0],
+ 0.5*fgkSSDLadderCableWidth,
+ 0.5*fgkSSDFlexHeight[0]),
+ new TGeoTranslation("LadderCableSegmentBBoxTrans2",
+ 0.5*fgkSSDFlexWidth[0],
+ 0.5*fgkSSDLadderCableWidth,
+ fgkSSDFlexHeight[0]
+ +0.5*fgkSSDFlexHeight[1])
+ };
+ static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
+ static TGeoVolume* laddercablesegmentarbassembly =
+ new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
+
+ static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
+ static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
+
+ if (laddercablesegmentbboxshape[0] == 0) {
+ // Initialise static shapes and volumes
for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
new TGeoBBox(laddercablesegmentbboxshapename[i],
0.5*fgkSSDFlexWidth[0],
0.5*fgkSSDLadderCableWidth,
0.5*fgkSSDFlexHeight[i]);
- const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
- {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
- TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
+
for(Int_t i=0; i<kladdercablesegmentnumber; i++){
laddercablesegmentbbox[i] =
new TGeoVolume(laddercablesegmentbboxname[i],
laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
fColorPolyhamide);
}
- TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
- laddercablesegmentbboxtrans[0] =
- new TGeoTranslation("LadderCableSegmentBBoxTrans1",
- 0.5*fgkSSDFlexWidth[0],
- 0.5*fgkSSDLadderCableWidth,
- 0.5*fgkSSDFlexHeight[0]);
- laddercablesegmentbboxtrans[1] =
- new TGeoTranslation("LadderCableSegmentBBoxTrans2",
- 0.5*fgkSSDFlexWidth[0],
- 0.5*fgkSSDLadderCableWidth,
- fgkSSDFlexHeight[0]
- +0.5*fgkSSDFlexHeight[1]);
- TGeoVolume* laddercablesegmentbboxassembly =
- new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
+
for(Int_t i=0; i<kladdercablesegmentnumber; i++)
laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
laddercablesegmentbboxtrans[i]);
}
Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
{fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
- char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
+ const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
- TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
+
for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
GetArbShape(laddercablesegmentvertexposition[i],
laddercablesegmentwidth[i],
laddercablesegmentarbshapename[i]);
const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
{"LadderCableSegmentArb1","LadderCableSegmentArb2"};
- TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
+
for(Int_t i=0; i<kladdercablesegmentnumber; i++){
laddercablesegmentarb[i] =
new TGeoVolume(laddercablesegmentarbname[i],
+ fgkSSDFlexWidth[0],0.,0.,
new TGeoRotation((*laddercablesegmentarbrot[1])
*(*laddercablesegmentarbrot[0])));
- TGeoVolume* laddercablesegmentarbassembly =
- new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
for(Int_t i=0; i<kladdercablesegmentnumber; i++)
laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
laddercablesegmentarbcombitrans);
+ } // End of static initialisations
/////////////////////////////////////////
// End Ladder Cable Volume
+// Note: this part depends explicitly on the length passed as an argument to the function
/////////////////////////////////////////
TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
laddercablesegmentlist->Add(laddercablesegmentarbassembly);
laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
return laddercablesegmentlist;
- }
+}
+
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
// 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);
Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
* (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
- ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
- - fgkSSDModuleVerticalDisalignment;
+ ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
xmothervertex[0][1] = xmothervertex[0][0];
ymothervertex[0][1] = 0.0;
xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
xmothervertex[1][i] = xmothervertex[0][i];
ymothervertex[1][i] = ymothervertex[0][i];
}
+///////////////////////////////////////////////////////////////////////////
+// Disalignement Mother Volume corrections 25/08/08
+///////////////////////////////////////////////////////////////////////////
+ TGeoXtru* leftladdershape1[fgkladdernumber];
+ TGeoXtru* leftladdershape2[fgkladdernumber];
+ TGeoXtru* centersensorladdershape[fgkladdernumber];
+ TGeoXtru* rightladdershape1[fgkladdernumber];
+ TGeoXtru* rightladdershape2[fgkladdernumber];
+ for(Int_t i=0; i<fgkladdernumber; i++){
+ leftladdershape1[i] = new TGeoXtru(2);
+ leftladdershape2[i] = new TGeoXtru(2);
+ centersensorladdershape[i] = new TGeoXtru(2);
+ rightladdershape1[i] = new TGeoXtru(2);
+ rightladdershape2[i] = new TGeoXtru(2);
+ }
+ //////////////////////////////////////
+ // Setting the names for shapes
+ //////////////////////////////////////
+ leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
+ leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
+ leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
+ leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
+ centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
+ centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
+ rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
+ rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
+ rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
+ rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
+ //////////////////////////////////////
+ Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
+ Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
+ Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
+ Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
+ Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
+ Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
+ for(Int_t i=0; i<fgkladdernumber; i++) {
+ for(Int_t j=0; j<kmothervertexnumber; j++){
+ xcentersensorvertex[i][j] = xmothervertex[i][j];
+ ycentersensorvertex[i][j] = ymothervertex[i][j];
+ xend1laddervertex[i][j] = xmothervertex[i][j];
+ yend1laddervertex[i][j] = ymothervertex[i][j];
+ xend2laddervertex[i][j] = xmothervertex[i][j];
+ yend2laddervertex[i][j] = ymothervertex[i][j];
+ }
+ // Add some space around sensors to accommodate misalignments
+ xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
+ xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
+ xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
+ xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
+
+ ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
+ ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
+
+ // 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);
+
+ // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
+
+ // Cuts off first corner (neg x)
+ xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
+ xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
+ // Cuts off last part (pos x)
+ xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
+ xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
+
+ leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
+ yend1laddervertex[i]);
+ leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
+ leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
+ - fgkEndLadderMountingBlockPosition[0]);
+
+ leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
+ yend2laddervertex[i]);
+ leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
+ - fgkEndLadderMountingBlockPosition[0]);
+ leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
+ + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
+
+ rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
+ yend1laddervertex[i]);
+ rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
+ +fgkEndLadderCarbonFiberLowerJunctionLength[0]
+ -2.4*fgkSSDMountingBlockWidth);
+ rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
+ + fgkEndLadderMountingBlockPosition[1]);
+
+ rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
+ yend2laddervertex[i]);
+ rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
+ + fgkEndLadderMountingBlockPosition[1]);
+ rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
+ + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
+ }
+ TGeoCompositeShape* laddershapecontainer[2];
+ laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
+ "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
+ "+Lay5CenterSensorContainer"
+ "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
+ laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
+ "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
+ "+Lay6CenterSensorContainer"
+ "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
for(Int_t i=0; i<fgkladdernumber; i++){
- laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
- ymothervertex[i]);
- laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
- laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
- +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
- fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
- fladder[i]->SetLineColor(4);
- }
+ fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
+ fladder[i]->SetLineColor(4);
+ }
///////////////////////////////////////////////////////////////////////////
if(!fCreateMaterials) CreateMaterials();
if(!fTransformationMatrices) CreateTransformationMatrices();
///////////////////////////////
/// Placing End Ladder Segment
///////////////////////////////
- fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
+ fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
}
/////////////////////////////////////////////////////////////////////////////
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]);
}
}
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
- for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
+ for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
}
////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
// Insert the layer 5 in the mother volume.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
+ AliError("Can't insert layer5, mother is null!\n");
return;
};
if(!fSSDLayer5) SetLayer();
// Insert the layer 6 in the mother volume.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
+ AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
return;
};
if(!fSSDLayer6) SetLayer();
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);
centermountingsupportshape[i]->DefineSection(0,0.);
centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
-fgkMountingBlockSupportWidth[0]);
+
centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
centermountingsupportshape[i],
fSSDAlCoolBlockMedium);
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
sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
- + fgkMountingBlockSupportDownHeight;
+ + fgkMountingBlockSupportDownHeight
+ - fgkSSDLadderVerticalDisalignment;
mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
+ fgkSSDMountingBlockHeight[1]
- 0.5*fgkCoolingTubeSupportHeight
- - fgkSSDModuleCoolingBlockToSensor
- - 2.*fgkSSDModuleVerticalDisalignment;
+ - fgkSSDModuleCoolingBlockToSensor;
mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
mountingblockpiecedown[i]->SetLineColor(fColorG10);
+
///////////////////////////
// Mounting Block Up Vertex
///////////////////////////
sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
- + fgkMountingBlockSupportUpHeight[i];
+ + fgkMountingBlockSupportUpHeight[i]
+ - fgkSSDLadderVerticalDisalignment;
mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
+ fgkSSDMountingBlockHeight[1]
- 0.5*fgkCoolingTubeSupportHeight
- - fgkSSDModuleCoolingBlockToSensor
- - 2.*fgkSSDModuleVerticalDisalignment;
+ - fgkSSDModuleCoolingBlockToSensor;
mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
+
mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
mountingblockpieceupyvertex[i]);
mountingblockpieceupshape[i]->DefineSection(0,0.0);
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++){
////////////////////////////////////////////
mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
+
mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
mountingblocksupportrapezoidownyvertex[i]);
mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
+
mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
mountingblocksupportrapezoidupyvertex[i]);
mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
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* downmotherladdersupportshape[fgklayernumber];
TGeoVolume* downmotherladdersupport[fgklayernumber];
TGeoXtru* upmotherladdersupportshape[fgklayernumber];
-// TGeoVolume* upmotherladdersupport[fgklayernumber];
- TGeoVolumeAssembly* upmotherladdersupport[fgklayernumber];
- char upmotheladdersupportname[30];
- char downmotheladdersupportname[30];
+ TGeoVolume* upmotherladdersupport[fgklayernumber];
+ char upmotheladdersupportname[100];
+ char downmotheladdersupportname[100];
for(Int_t i=0; i<fgklayernumber; i++){
xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
- mountingsupportedge[i];
ymothervertex[i][6] = ymothervertex[i][5];
xmothervertex[i][7] = xmothervertex[i][6];
ymothervertex[i][7] = ymothervertex[i][0];
+
sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
- downmotherladdersupportshape[i] = new TGeoXtru(2);
+
+ downmotherladdersupportshape[i] = new TGeoXtru(2);
downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
- downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
+ downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
+ fgkMountingBlockSupportDownHeight
+ fgkSSDMountingBlockHeight[1]
- 0.5*fgkCoolingTubeSupportHeight
- fgkSSDModuleCoolingBlockToSensor
- - 2.*fgkSSDModuleVerticalDisalignment);
- downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
- downmotherladdersupportshape[i],fSSDAir);
+ - fgkSSDLadderVerticalDisalignment);
+
+// - fgkSSDModuleVerticalDisalignment);
+ //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
+
+ downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
+ downmotherladdersupportshape[i],fSSDAir);
upmotherladdersupportshape[i] = new TGeoXtru(2);
upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
+ fgkSSDMountingBlockHeight[1]
- 0.5*fgkCoolingTubeSupportHeight
- fgkSSDModuleCoolingBlockToSensor
- - 2.*fgkSSDModuleVerticalDisalignment);
- upmotherladdersupport[i] = new TGeoVolumeAssembly(upmotheladdersupportname);
-// upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
-// upmotherladdersupportshape[i],fSSDAir);
+ - fgkSSDLadderVerticalDisalignment);
+
+ upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
+ upmotherladdersupportshape[i],fSSDAir);
}
for(Int_t i=0; i<fgklayernumber; i++){
/////////////////////////
/////////////////////////
boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
- + 0.5*fgkMountingBlockSupportDownHeight;
+ + 0.5*fgkMountingBlockSupportDownHeight
+ - 0.5*fgkSSDLadderVerticalDisalignment;
boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
- 0.5*fgkMountingBlockSupportWidth[0];
boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
- + 0.5*fgkMountingBlockSupportUpHeight[i];
+ + 0.5*fgkMountingBlockSupportUpHeight[i]
+ - 0.5*fgkSSDLadderVerticalDisalignment;
boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
- 0.5*fgkMountingBlockSupportWidth[0];
boxoriginup[i][1][0] = 0.0;
- boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
- + 0.5*fgkMountingBlockSupportUpHeight[i];
+ boxoriginup[i][1][1] = boxoriginup[i][0][1];
boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
- fgkMountingBlockSupportWidth[0]);
/////////////////////////
mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
+ fgkSSDMountingBlockLength[0]),
- 0.5*fgkMountingBlockSupportDownHeight,
+ 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
0.5*fgkMountingBlockSupportWidth[0],
boxorigindown[i][0]);
- mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
- 0.5*fgkMountingBlockSupportDownHeight,
+ mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
+ 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
0.5*(fgkMountingBlockSupportWidth[1]
- fgkMountingBlockSupportWidth[0]),
boxorigindown[i][1]);
mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
+ fgkSSDMountingBlockLength[0]),
- 0.5*fgkMountingBlockSupportUpHeight[i],
+ 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
0.5*fgkMountingBlockSupportWidth[0],
boxoriginup[i][0]);
-
+
mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
- 0.5*fgkMountingBlockSupportUpHeight[i],
+ 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
0.5*(fgkMountingBlockSupportWidth[1]
- fgkMountingBlockSupportWidth[0]),
boxoriginup[i][1]);
///////////////////////////////////////
- // Adding the Volumes to Mother Volume
+ // Adding the Volumes to Mother Volume
///////////////////////////////////////
for(Int_t j=0; j<2; j++){
sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
mountingblocksupportboxup[i][j]->SetLineColor(9);
for(Int_t k=0; k<2; k++){
downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
}
}
for(Int_t k=0; k<2; k++){
downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
- downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
+ downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
-// upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
+ upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
}
}
TList* laddersupportlist = new TList();
delete [] ysidelowervertex[i];
delete [] xcenterlowervertex[i];
delete [] ycenterlowervertex[i];
+ delete [] xmothervertex[i];
+ delete [] ymothervertex[i];
}
- delete xsidevertex;
- delete ysidevertex;
- delete xcentervertex;
- delete ycentervertex;
- delete xsidelowervertex;
- delete ysidelowervertex;
- delete xcenterlowervertex;
- delete ycenterlowervertex;
+ delete [] xsidevertex;
+ delete [] ysidevertex;
+ delete [] xcentervertex;
+ delete [] ycentervertex;
+ delete [] xsidelowervertex;
+ delete [] ysidelowervertex;
+ delete [] xcenterlowervertex;
+ delete [] ycenterlowervertex;
delete globalrefladdersupportrot;
delete mountingblocksupportrot;
/////////////////////
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]};
delete [] xmothervertex[i];
delete [] ymothervertex[i];
}
- delete xmothervertex;
- delete ymothervertex;
+ delete [] xmothervertex;
+ delete [] ymothervertex;
delete globalrot;
for(Int_t i=0; i<fgklayernumber; i++){
for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
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);
for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
delete endcapassemblyrot[i][j];
}
- delete endcapassemblyrot[i];
+ delete [] endcapassemblyrot[i];
delete endcapassemblymatrix[i][0];
delete endcapassemblymatrix[i][1];
}
// Setting End Cap Support + End Cap Assembly of Layer 5.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
+ AliError("Can't insert end cap support of layer5, mother is null!\n");
return;
};
if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
// Setting End Cap Support + End Cap Assembly of Layer 6.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
+ AliError("Can't insert end cap support of layer6, mother is null!\n");
return;
};
if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
// Setting Ladder Support of Layer 5.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
+ AliError("Can't insert ladder lupport of layer5, mother is null!\n");
return;
};
if(!fLay5LadderSupportRing) SetLadderSupport(100);
// Setting Ladder Support of Layer 6.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
+ AliError("Can't insert ladder lupport of layer6, mother is null!\n");
return;
};
if(!fLay6LadderSupportRing) SetLadderSupport(100);
// Setting Ladder Support of Layer 6.
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cone, mother is null!\n");
+ AliError("Can't insert SSD Cone, mother is null!\n");
return;
};
if(!fSSDCone) SetSSDCone();
// Setting SSD Cables
/////////////////////////////////////////////////////////////
if (! moth) {
- printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cables, mother is null!\n");
+ AliError("Can't insert SSD Cables, mother is null!\n");
return;
};
TGeoVolume* ssdcables = SetSSDCables();
for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
- + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
+ + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
- + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
+ + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
////////////////////////////////////
//cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
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
/////////////////////////////////////////////////////////////
const Int_t kvertexnumber = 8;
const Int_t ktransvectnumber = 2;
- TVector3* vertex[kvertexnumber];
- TVector3* transvector[2];
- for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
+ TVector3 vertex[kvertexnumber];
+ TVector3 transvector[2];
+ for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
/////////////////////////////////////////////////////////////
//Setting the vertices for TGeoArb8
/////////////////////////////////////////////////////////////
- vertex[0] = new TVector3(*vertexpos[0]);
- vertex[1] = new TVector3(*vertexpos[1]);
- vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
- vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
- vertex[4] = new TVector3(*vertexpos[2]);
- vertex[5] = new TVector3(*vertexpos[3]);
- vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
- vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
+ vertex[0] = *vertexpos[0];
+ vertex[1] = *vertexpos[1];
+ vertex[2] = vertex[1];
+ vertex[3] = vertex[0];
+ vertex[4] = *vertexpos[2];
+ vertex[5] = *vertexpos[3];
+ vertex[6] = vertex[5];
+ vertex[7] = vertex[4];
+
+ // NB: order of points is clockwise
+ if (isign < 0) {
+ vertex[2] -= transvector[0];
+ vertex[3] -= transvector[0];
+ vertex[6] -= transvector[1];
+ vertex[7] -= transvector[1];
+ }
+ else {
+ vertex[0] += transvector[0];
+ vertex[1] += transvector[0];
+ vertex[4] += transvector[1];
+ vertex[5] += transvector[1];
+ }
+
/////////////////////////////////////////////////////////////
TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
- for(Int_t i = 0; i<kvertexnumber;i++)
- arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
- /////////////////////////////////////////////////////////////
- // Deallocating memory
- /////////////////////////////////////////////////////////////
- for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
- for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
- /////////////////////////////////////////////////////////////
+ for(Int_t i = 0; i<kvertexnumber;i++) {
+ arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
+ }
+
return arbshape;
}
///////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// Method returning the Medium type
/////////////////////////////////////////////////////////////
- char ch[30];
+ char ch[100];
sprintf(ch, "ITS_%s",mediumName);
TGeoMedium* medium = gGeoManager->GetMedium(ch);
if (! medium)
- printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
+ AliError(Form("medium %s not found !\n", mediumName));
return medium;
}
////////////////////////////////////////////////////////////////////////////////
fCreateMaterials = kTRUE;
}
/////////////////////////////////////////////////////////////////////
-