#include "TList.h"
#include "TGeoMatrix.h"
#include "TGeoCompositeShape.h"
+#include "TGeoBoolNode.h"
#include "TGeoTube.h"
#include "TGeoBBox.h"
#include "TGeoXtru.h"
#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.520*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.180*fgkmm-fgkSSDModuleVerticalDisalignment2};
+ { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
+ 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
// { 4.520*fgkmm, 5.130*fgkmm};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
{ 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
- (fgkSSDSensorSideSupportHeight[1]
- fgkSSDSensorSideSupportHeight[0])
- - fgkSSDModuleVerticalDisalignment2
+ - fgkSSDModuleVerticalDisalignment
- fgkSSDCoolingBlockHoleCenter
- fgkSSDStiffenerHeight
- fgkSSDChipHeight-fgkSSDSensorHeight,
fgkSSDModuleCoolingBlockToSensor
- - fgkSSDModuleVerticalDisalignment2
+ - fgkSSDModuleVerticalDisalignment
- fgkSSDCoolingBlockHoleCenter
- fgkSSDStiffenerHeight
- fgkSSDChipHeight-fgkSSDSensorHeight};
/////////////////////////////////////////////////////////////////////////////////
// Carbon Fiber Lower Support Parameters (lengths are in mm)
/////////////////////////////////////////////////////////////////////////////////
+const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
= 0.950*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
1.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
6.0*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
+const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
4.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
{ 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
- 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::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeigth = 87.5*fgkmm;
+const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
fcoolingblocksystematrix(),
fssdstiffenerflex(),
fssdendflex(),
+ fcoolingtube(0),
fendladdercoolingtubesupportmatrix(),
fendladdermountingblock(),
fendladdermountingblockclip(),
fcoolingblocksystematrix(s.fcoolingblocksystematrix),
fssdstiffenerflex(s.fssdstiffenerflex),
fssdendflex(s.fssdendflex),
+ fcoolingtube(s.fcoolingtube),
fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
fendladdermountingblock(s.fendladdermountingblock),
fendladdermountingblockclip(s.fendladdermountingblockclip),
/////////////////////////////////////////////////////////////
TGeoRotation* localcoolingtuberot = new TGeoRotation();
localcoolingtuberot->SetAngles(0.,90.,0.);
- TGeoTranslation** localcoolingtubetrans[4];
- TVector3** localcoolingtubevect[4];
- for(Int_t i=0; i<4; i++){
- localcoolingtubevect[i] = new TVector3*[2];
- localcoolingtubetrans[i] = new TGeoTranslation*[2];
- fcoolingtubematrix[i] = new TGeoHMatrix*[2];
- }
- localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
+ TGeoTranslation* localcoolingtubetrans[2];
+ TVector3* localcoolingtubevect[2];
+
+ localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
-fgkCarbonFiberTriangleLength),
- - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth
- + fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])+
- 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
- - 2.0*fgkSSDModuleStiffenerPosition[1]
- - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
- - 0.5*fgkCoolingTubeSupportWidth,
- - 0.5*fgkCoolingTubeSupportHeight);
- localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
- localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
- - 2.0*fgkSSDModuleStiffenerPosition[1]
- - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
- + fgkCoolingTubeSupportWidth,
- localcoolingtubevect[0][0]->Z());
- localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
- + fgkCarbonFiberTriangleLength,
- localcoolingtubevect[0][0]->Y(),
- localcoolingtubevect[0][0]->Z());
- localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
- + fgkCarbonFiberTriangleLength,
- localcoolingtubevect[0][1]->Y(),
- localcoolingtubevect[0][1]->Z());
- localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
- - fgkCarbonFiberTriangleLength),
- - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth
- + fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])
- + fgkSSDModuleStiffenerPosition[1]
- - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
+ fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
+ - fgkCarbonFiberLowerSupportWidth
+ - fgkLowerSupportToSensorZ ,
- 0.5*fgkCoolingTubeSupportHeight);
- localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
- + fgkCarbonFiberTriangleLength,
- localcoolingtubevect[2][0]->Y(),
- localcoolingtubevect[2][0]->Z());
- localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
- - fgkCarbonFiberTriangleLength),
- - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth
- + fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])
- + fgkSSDSensorLength
- - 0.5*fgkSSDModuleStiffenerPosition[1],
- - 0.5*fgkCoolingTubeSupportHeight);
- localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
- + fgkCarbonFiberTriangleLength,
- localcoolingtubevect[3][0]->Y(),
- - 0.5*fgkCoolingTubeSupportHeight);
- for(Int_t i=0; i<4; i++)
+ localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
+ localcoolingtubevect[0]->Y(),
+ localcoolingtubevect[0]->Z());
for(Int_t j=0; j<2; j++){
- localcoolingtubetrans[i][j] =
- new TGeoTranslation(localcoolingtubevect[i][j]->X(),
- localcoolingtubevect[i][j]->Y(),
- localcoolingtubevect[i][j]->Z());
- fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
+ localcoolingtubetrans[j] =
+ new TGeoTranslation(localcoolingtubevect[j]->X(),
+ localcoolingtubevect[j]->Y(),
+ localcoolingtubevect[j]->Z());
+ fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
* (*localcoolingtuberot));
}
/////////////////////////////////////////////////////////////
TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
TGeoTranslation** localendlladdercoolingtubetrans[2];
- localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
- localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
+ localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
+ localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
for(Int_t i=0; i<2; i++)
- for(Int_t j=0; j<(i==0?6:4); j++)
+ for(Int_t j=0; j<2; j++)
localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
+
+ Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
- fgkCoolingTubeSupportRmax)
+ fgkCarbonFiberJunctionLength,
- 0.5*(fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]),
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
- 0.5*fgkCoolingTubeSupportHeight);
localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
- fgkCoolingTubeSupportRmax)
- fgkCarbonFiberJunctionLength
+ fgkCarbonFiberTriangleLength,
- 0.5*(fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]),
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
- 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- + fgkCarbonFiberJunctionLength,
- fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]
- + 0.5*(fgkendladdercoolingsupportdistance[0]
- + fgkendladdercoolingsupportdistance[1]
- + fgkCoolingTubeSupportWidth),
- - 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- - fgkCarbonFiberJunctionLength
- + fgkCarbonFiberTriangleLength,
- fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]
- + 0.5*(fgkendladdercoolingsupportdistance[0]
- + fgkendladdercoolingsupportdistance[1]
- + fgkCoolingTubeSupportWidth),
- - 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- + fgkCarbonFiberJunctionLength,
- fgkEndLadderCarbonFiberLowerJunctionLength[0]
- - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
- - fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[1]
- - fgkCoolingTubeSupportWidth),
- - 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- - fgkCarbonFiberJunctionLength
- + fgkCarbonFiberTriangleLength,
- fgkEndLadderCarbonFiberLowerJunctionLength[0]
- - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
- - fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[1]
- - fgkCoolingTubeSupportWidth),
- - 0.5*fgkCoolingTubeSupportHeight);
+
localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- + fgkCarbonFiberJunctionLength,
- - 0.50 * (fgkMountingBlockToSensorSupport
- - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
- - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
- + fgkSSDSensorOverlap
- + fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - fgkendladdercoolingsupportdistance[2]
- - fgkEndLadderMountingBlockPosition[1]
- - fgkCoolingTubeSupportWidth)
- + fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - fgkendladdercoolingsupportdistance[2]
- - fgkCoolingTubeSupportWidth,
+ - fgkCoolingTubeSupportRmax)
+ + fgkCarbonFiberJunctionLength,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
- 0.5*fgkCoolingTubeSupportHeight);
localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
- fgkCoolingTubeSupportRmax)
- fgkCarbonFiberJunctionLength
+ fgkCarbonFiberTriangleLength,
- - 0.50 * (fgkMountingBlockToSensorSupport
- - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
- - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
- + fgkSSDSensorOverlap
- + fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - fgkendladdercoolingsupportdistance[2]
- - fgkEndLadderMountingBlockPosition[1]
- - fgkCoolingTubeSupportWidth)
- + fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - fgkendladdercoolingsupportdistance[2]
- - fgkCoolingTubeSupportWidth,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
- 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- + fgkCarbonFiberJunctionLength,
- fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - 0.5*fgkendladdercoolingsupportdistance[2],
- - 0.5*fgkCoolingTubeSupportHeight);
- localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
- - fgkCoolingTubeSupportRmax)
- - fgkCarbonFiberJunctionLength
- + fgkCarbonFiberTriangleLength,
- fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - 0.5*fgkendladdercoolingsupportdistance[2],
- - 0.5*fgkCoolingTubeSupportHeight);
- fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
- fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
for(Int_t i=0; i<2; i++)
- for(Int_t j=0; j<(i==0?6:4); j++){
+ for(Int_t j=0; j<2; j++){
fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
}
- 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];
localladdercablerot[1]->SetAngles(90.,60.,-90.);
localladdercablerot[2]->SetRotation((*localladdercablerot[1])
* (*localladdercablerot[0]));
+ //TGeoRotation* localladdercablerot = new TGeoRotation();
+ //localladdercablerot->SetAngles(90.,0.,0.);
////////////////////////////////////////////
// LocalLadderCableCombiTransMatrix
////////////////////////////////////////////
TGeoTranslation* localssdsensortrans[2];
for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
- - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+ fgkCarbonFiberJunctionWidth
+ - fgkCarbonFiberLowerSupportWidth
+ - fgkLowerSupportToSensorZ,
0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
- - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
+ - fgkSSDModuleCoolingBlockToSensor
+ (fgkSSDSensorSideSupportHeight[1]
- - fgkSSDSensorSideSupportHeight[0])
- + 0.5*fgkSSDModuleVerticalDisalignment2);
+ - fgkSSDSensorSideSupportHeight[0]));
localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
- - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
- fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
- + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
- - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
- - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
+ fgkCarbonFiberJunctionWidth
+ - fgkCarbonFiberLowerSupportWidth
+ - fgkLowerSupportToSensorZ,
0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
- -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
- + 0.5*fgkSSDModuleVerticalDisalignment2);
+ -fgkSSDModuleCoolingBlockToSensor);
+
for(Int_t i=0; i<2; i++)
localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
*localssdsensorrot);
delete localcoolingtubesupportrot[i];
delete localcoolingtubesupportrans[i];
}
- for(Int_t i=0; i<4; i++){
- for(Int_t j=0; j<2; j++){
- delete localcoolingtubevect[i][j];
- delete localcoolingtubetrans[i][j];
- }
- delete [] localcoolingtubevect[i];
- delete [] localcoolingtubetrans[i];
+ for(Int_t j=0; j<2; j++){
+ delete localcoolingtubevect[j];
+ delete localcoolingtubetrans[j];
}
delete endladdermountingblockrot;
for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
}
delete localendlladdercoolingtuberot;
for(Int_t i=0; i<2; i++){
- for(Int_t j=0; j<(i==0?6:4); j++)
- delete localendlladdercoolingtubetrans[i][j];
+ for(Int_t j=0; j<2; j++)
+ delete localendlladdercoolingtubetrans[i][j];
delete [] localendlladdercoolingtubetrans[i];
}
/////////////////////////////////////////////////////////////
// SSD Cooling Tube Support
/////////////////////////////////////////////////////////////
- Int_t edgesnumber = 16;
+ Int_t edgesnumber = 3;
fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
/////////////////////////////////////////////////////////////
// SSD Hybrid
/////////////////////////////////////////////////////////////
// SSD Cooling Tube
/////////////////////////////////////////////////////////////
- TList* coolingtubelist = GetCoolingTubeList();
- for(Int_t i=0; i<fgkcoolingtubenumber; i++)
- fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
- for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
- fendladdercoolingtube[i] =
- (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
+ CreateCoolingTubes();
/////////////////////////////////////////////////////////////
// SSD Flex
/////////////////////////////////////////////////////////////
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];
// Vertex Positioning for TGeoXTru
///////////////////////////////////////
TVector3** vertexposition = new TVector3*[kvertexnumber];
- vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
- fgkCoolingTubeSupportRmin*SinD(angle));
+
+ Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
+ vertexposition[0] = new TVector3(Router*CosD(angle),
+ Router*SinD(angle));
vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
fgkCoolingTubeSupportRmax*SinD(angle));
vertexposition[2] = new TVector3(vertexposition[1]->X(),
fgkCoolingTubeSupportRmax);
vertexposition[4] = new TVector3(-vertexposition[1]->X(),
vertexposition[1]->Y());
+
for(Int_t i=0; i<nedges; i++)
vertexposition[i+5] =
- new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
- fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
+ new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
+ Router*SinD(psi+i*(2.*phi/nedges)));
///////////////////////////////////////////////////////////////////////
// TGeoXTru Volume definition for Cooling Tube Support Arc Part
///////////////////////////////////////////////////////////////////////
ymothervertex);
virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
- TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
- virtualCoolingTubeSupportShape,fSSDAir);
+ /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
+ virtualCoolingTubeSupportShape,fSSDAir); */
+ TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
+
////////////////////////////////////////
// Positioning Volumes in Virtual Volume
////////////////////////////////////////
virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
- virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
- virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
- virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
- virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
+ //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
+ //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
+ //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
+ //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
delete [] vertexposition;
- delete xvertexpoints;
- delete yvertexpoints;
- delete xvert;
- delete yvert;
+ delete [] xvertexpoints;
+ delete [] yvertexpoints;
+ delete [] xvert;
+ delete [] yvert;
for(Int_t i=0; i< kvirtualvertexnumber; i++)
delete virtualvertex[i];
/////////////////////////////////////////////////////////////
// Mother Volumes Containers
/////////////////////////////////////////////////////////////
const Int_t kmothernumber = 2;
- const Int_t kmothervertexnumber = 12;
+ const Int_t kmothervertexnumber = 8;
Double_t xmothervertex[kmothernumber][kmothervertexnumber];
Double_t ymothervertex[kmothernumber][kmothervertexnumber];
- ///////////////////////
- // Setting the vertices
- ///////////////////////
- xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
- xmothervertex[0][1] = xmothervertex[0][0];
- xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
- xmothervertex[0][3] = xmothervertex[0][2];
- xmothervertex[0][4] = xmothervertex[0][0];
- xmothervertex[0][5] = xmothervertex[0][4];
- xmothervertex[0][6] = -xmothervertex[0][0];
- xmothervertex[0][7] = xmothervertex[0][6];
- xmothervertex[0][8] = -xmothervertex[0][2];
- xmothervertex[0][9] = xmothervertex[0][8];
- xmothervertex[0][10] = xmothervertex[0][7];
- xmothervertex[0][11] = xmothervertex[0][10];
- for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
- for(Int_t i = 0; i<kmothernumber; i++){
- ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
- + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
- ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
- ymothervertex[i][2] = ymothervertex[i][1];
- ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
- ymothervertex[i][4] = ymothervertex[i][3];
- ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
- ymothervertex[i][6] = ymothervertex[i][5];
- ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
- ymothervertex[i][8] = ymothervertex[i][7];
- ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
- ymothervertex[i][10] = ymothervertex[i][9];
- ymothervertex[i][11] = ymothervertex[i][0];
- }
- TGeoXtru* ssdhybridmothershape[kmothernumber];
-// TGeoVolume* ssdhybridmother[kmothernumber];
- TGeoVolumeAssembly* ssdhybridmother[kmothernumber];
+
+ TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
+ TGeoVolume* ssdhybridmother[kmothernumber][2];
+
+ TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
+ TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
+ TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
+
const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
for(Int_t i=0; i<kmothernumber; i++){
- ssdhybridmothershape[i] = new TGeoXtru(2);
- ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
- ymothervertex[i]);
- ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
- -fgkSSDChipCablesHeight[i+2]);
- ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
-// ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
-// fSSDAir);
- ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
+ xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
+ xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
+ -fgkSSDChipCablesHeight[i+2];
+
+ xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
+ ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
+ xmothervertex[i][3] = xmothervertex[i][2];
+ ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
+
+ xmothervertex[i][4] = xmothervertex[i][2]-0.4;
+ ymothervertex[i][4] = ymothervertex[i][3];
+ xmothervertex[i][5] = xmothervertex[i][4];
+ ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
+
+ xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
+ ymothervertex[i][6] = ymothervertex[i][5];
+
+ xmothervertex[i][7] = xmothervertex[i][6];
+ ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
+ /*
+ for (Int_t j = 0; j<8; j++) {
+ cout << "vtx " << j << " " << xmothervertex[i][j] << " " << ymothervertex[i][j] << endl;
+ }
+ */
+ TGeoXtru *shape = new TGeoXtru(2);
+ shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
+ shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
+ shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
+ ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
+ ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
+ ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
}
/////////////////////////////////////////////////////////////
// SSD Stiffener
TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
fSSDStiffenerMedium);
ssdstiffener->SetLineColor(fColorStiffener);
- TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
- for(Int_t i=0; i<kssdstiffenernumber; i++)
- ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
- /////////////////////////////////////////////////////////////
- // SSD Chip System
- /////////////////////////////////////////////////////////////
- TList* ssdchipsystemlist = GetSSDChipSystem();
- Double_t ssdchipseparation = fgkSSDSensorLength
- - 2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
- - 0.5*fgkSSDChipWidth);
- Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
- + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
- TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
- - 0.5*ssdchipsystemlength,
- 0.5*(ssdstiffenerseparation-ssdchipseparation),
- - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
+
////////////////////////////
// Capacitor 0603-2200 nF
///////////////////////////
const Int_t knapacitor0603number = 5;
TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
- 0.5*fgkSSDCapacitor0603Length,
- 0.5*(fgkSSDCapacitor0603Width),
- 0.5*fgkSSDCapacitor0603Height);
+ 0.5*fgkSSDCapacitor0603Length,
+ 0.5*(fgkSSDCapacitor0603Width),
+ 0.5*fgkSSDCapacitor0603Height);
TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
fSSDStiffener0603CapacitorMedium);
capacitor0603->SetLineColor(fColorAl);
+
+ TGeoVolume* ssdchip = GetSSDChip();
+
+ const Int_t knedges = 5;
+ TGeoVolume *ssdchipcables[2];
+
for(Int_t i=0; i<kmothernumber; i++){
+ for(Int_t j=0; j<kssdstiffenernumber; j++){
+ ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
+ for(Int_t k=1; k<knapacitor0603number+1; k++){
+ ssdhybridmother[i][j]->AddNode(capacitor0603,k,
+ new TGeoCombiTrans("",
+ -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
+ -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
+ (k-3.)/6*fgkSSDStiffenerLength,
+ hybridmotherrotInv));
+ }
+ }
+
+ GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
+ for(Int_t k=0; k<fgkSSDChipNumber; k++){
+ TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
+ - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
+ - fgkSSDChipCablesHeight[i+2],
+ (k+0.5-fgkSSDChipNumber/2)*
+ (fgkSSDChipLength + fgkSSDChipSeparationLength));
+ TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
+ - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
+ (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
+ hybridmotherrotInv);
for(Int_t j=0; j<kssdstiffenernumber; j++){
- ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
- for(Int_t k=1; k<knapacitor0603number+1; k++){
- ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
- new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
- j*ssdstiffenerseparation
- + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
- + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
- - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
- }
- }
- ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
- ssdhybridlist->Add(ssdhybridmother[i]);
+ ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
+ ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
+ }
+ }
+ // Final placement by assembly
+ ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
+ ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
+ ssdhybridlist->Add(ssdhybridassembly[i]);
}
-/////////////////////////////////////////////////////////////
-// Mother Volume Containing Capacitor Part
-/////////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////////
+ // Mother Volume Containing Capacitor Part
+ /////////////////////////////////////////////////////////////
const Int_t kcapacitormothernumber = 8;
Double_t xcapacitorvertex[kcapacitormothernumber];
Double_t ycapacitorvertex[kcapacitormothernumber];
- 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);
/////////////////////////////////////////////////////////////
delete hybridwirecombitrans[0];
delete hybridwirecombitrans[1];
- delete ssdchipsystemlist;
return ssdhybridlist;
/////////////////////////////////////////////////////////////
}
coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
+ fgkCoolingTubeRmax));
TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
-// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
-// coolingsystemothershape,fSSDAir);
- /////////////////////////////////////////////////////////////
- // SSD Cooling Tube Part
- /////////////////////////////////////////////////////////////
- TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
- coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
- coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
- TGeoVolume* coolingtube[fgkcoolingtubenumber];
- coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
- fSSDCoolingTubePhynox);
- coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
- fSSDCoolingTubeWater);
- coolingtube[0]->SetLineColor(fColorPhynox);
- coolingtube[1]->SetLineColor(fColorWater);
TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
/////////////////////////////////////////////////////////////
// Adding Cooling block to mother volume
/////////////////////////////////////////////////////////////
- for(Int_t i=0; i<kcoolingblocknumber; i++){
- coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
- coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
- coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
+ for(Int_t i=0; i<kcoolingblocknumber; i++){
+ coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
}
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
- delete coolingblocktransvector;
- delete localcoolingblockrot;
- delete localcoolingtubetrans;
- delete localcoolingtuberot;
- /////////////////////////////////////////////////////////////
- // Checking overlaps
- /////////////////////////////////////////////////////////////
- //coolingsystemother->CheckOverlaps(0.01);
- /////////////////////////////////////////////////////////////
- return coolingsystemother;
+ delete coolingblocktransvector;
+ delete localcoolingblockrot;
+
+ return coolingsystemother;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
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
///////////////////////////////////////////////////////////////////////
Int_t edgesnumber[2] = {50,6};
Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
+0.5*(ymothervertex[3]-ymothervertex[2])};
- TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
+ TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
clipscrew->SetLineColor(12);
TGeoRotation* screwrot = new TGeoRotation();
return ssdmountingblockclip;
}
///////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
+void AliITSv11GeometrySSD::CreateCoolingTubes() {
/////////////////////////////////////////////////////////////
// Method generating the Cooling Tube
+ // sets fcoolingtube and returns list for endladdercoolingtube
/////////////////////////////////////////////////////////////
- TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
- for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
- new TGeoTube*[2];
- // Ladder Cooling Tubes
- coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
- coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[0][0]->GetDz());
- coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDModuleStiffenerPosition[1]
- - fgkSSDSensorOverlap));
- coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[1][0]->GetDz());
- coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.5*(fgkSSDModuleStiffenerPosition[1]));
- coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- coolingtubeshape[2][0]->GetDz());
- // End Ladder Cooling Tubes
- TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
- for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
- endladdercoolingtubeshape[i] = new TGeoTube*[2];
- endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkEndLadderMountingBlockPosition[0]
- - fgkendladdercoolingsupportdistance[0]-fgkSSDTolerance));
- endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[0][0]->GetDz());
- endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkendladdercoolingsupportdistance[0]
- + fgkendladdercoolingsupportdistance[1]
- - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
- endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[1][0]->GetDz());
- 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[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkMountingBlockToSensorSupport
- - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
- - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
- + fgkSSDSensorOverlap
- + fgkEndLadderCarbonFiberLowerJunctionLength[1]
- - fgkendladdercoolingsupportdistance[2]
- - fgkEndLadderMountingBlockPosition[1]
- - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
- endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[3][0]->GetDz());
- endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
- 0.50 * (fgkendladdercoolingsupportdistance[2]-fgkSSDTolerance));
- endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
- endladdercoolingtubeshape[4][0]->GetDz());
- // Ladder Cooling Tubes
- TGeoVolume** coolingtube[fgkcoolingtubenumber];
- for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
- new TGeoVolume*[2];
- coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
- fSSDCoolingTubePhynox);
- coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
- fSSDCoolingTubeWater);
- coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
- fSSDCoolingTubePhynox);
- coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
- fSSDCoolingTubeWater);
- coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
- fSSDCoolingTubePhynox);
- coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
- fSSDCoolingTubeWater);
- for(Int_t i=0; i<fgkcoolingtubenumber; i++){
- coolingtube[i][0]->SetLineColor(fColorPhynox);
- coolingtube[i][1]->SetLineColor(fColorWater);
- }
- // End Ladder Cooling Tubes
- TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
- for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
- endladdercoolingtube[i] = new TGeoVolume*[2];
- endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
- endladdercoolingtubeshape[0][0],
- fSSDCoolingTubePhynox);
- endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
- endladdercoolingtubeshape[0][1],
- fSSDCoolingTubeWater);
- endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
- endladdercoolingtubeshape[1][0],
- fSSDCoolingTubePhynox);
- endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
- endladdercoolingtubeshape[1][1],
- fSSDCoolingTubeWater);
- endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
- endladdercoolingtubeshape[2][0],
- fSSDCoolingTubePhynox);
- endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
- endladdercoolingtubeshape[2][1],
- fSSDCoolingTubeWater);
- endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
- endladdercoolingtubeshape[3][0],
- fSSDCoolingTubePhynox);
- endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
- endladdercoolingtubeshape[3][1],
- fSSDCoolingTubeWater);
- endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
- endladdercoolingtubeshape[4][0],
- fSSDCoolingTubePhynox);
- endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
- endladdercoolingtubeshape[4][1],
- fSSDCoolingTubeWater);
- for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
- endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
- endladdercoolingtube[i][1]->SetLineColor(fColorWater);
- }
+ TGeoTube *coolingtubeshape[2];
+ // Ladder Cooling Tubes
+
+ // MvL: Simplified cooling tubes
+ coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
+ coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
+
+ // End Ladder Cooling Tubes
+ TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdercoolingtubeshape[i] = new TGeoTube*[2];
+
+ Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
+ endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
+ endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[0][0]->GetDz());
+ endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
+ 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
+ endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
+ endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
+ // Ladder Cooling Tubes
+ TGeoVolume* coolingtube[2];
+ coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
+ coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
+ coolingtube[0]->SetLineColor(fColorPhynox);
+ coolingtube[1]->SetLineColor(fColorWater);
+
+ // End Ladder Cooling Tubes
+ TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
+ endladdercoolingtube[i] = new TGeoVolume*[2];
+ endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
+ endladdercoolingtubeshape[0][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
+ endladdercoolingtubeshape[0][1],
+ fSSDCoolingTubeWater);
+ endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
+ endladdercoolingtubeshape[1][0],
+ fSSDCoolingTubePhynox);
+ endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
+ endladdercoolingtubeshape[1][1],
+ fSSDCoolingTubeWater);
+ for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
+ endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
+ endladdercoolingtube[i][1]->SetLineColor(fColorWater);
+ }
+
/////////////////////////////////////////////////////////////
// Virtual Volume containing Cooling Tubes
/////////////////////////////////////////////////////////////
// Ladder Cooling Tubes
- TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
- for(Int_t i=0; i<fgkcoolingtubenumber; i++)
- virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
- coolingtubeshape[i][0]->GetRmax(),
- coolingtubeshape[i][0]->GetDz());
- TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
- virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
- fSSDAir);
- virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
- fSSDAir);
- virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
- fSSDAir);
+ TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
+ coolingtubeshape[0]->GetRmax(),
+ coolingtubeshape[0]->GetDz());
+ fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
+ fcoolingtube->AddNode(coolingtube[0],1);
+ fcoolingtube->AddNode(coolingtube[1],1);
+
// End Ladder Cooling Tubes
TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
- endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
- endladdercoolingtubeshape[i][0]->GetRmax(),
- endladdercoolingtubeshape[i][0]->GetDz());
- TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
- endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
- endladdervirtualcoolingtubeshape[0],
- fSSDAir);
- endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
- endladdervirtualcoolingtubeshape[1],
- fSSDAir);
- endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
- endladdervirtualcoolingtubeshape[2],
- fSSDAir);
- endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
- endladdervirtualcoolingtubeshape[3],
- fSSDAir);
- endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
- endladdervirtualcoolingtubeshape[4],
- fSSDAir);
- TList* coolingtubelist = new TList();
- for(Int_t i=0; i<fgkcoolingtubenumber; i++){
- virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
- virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
- coolingtubelist->Add(virtualcoolingtube[i]);
- }
- endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
- endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
- coolingtubelist->Add(endladdervirtualcoolingtube[0]);
- endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
- endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
- coolingtubelist->Add(endladdervirtualcoolingtube[1]);
- endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
- endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
- coolingtubelist->Add(endladdervirtualcoolingtube[2]);
- endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
- endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
- coolingtubelist->Add(endladdervirtualcoolingtube[3]);
- endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
- endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
- coolingtubelist->Add(endladdervirtualcoolingtube[4]);
- return coolingtubelist;
+ endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
+ endladdercoolingtubeshape[i][0]->GetRmax(),
+ endladdercoolingtubeshape[i][0]->GetDz());
+ fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
+ endladdervirtualcoolingtubeshape[0],
+ fSSDAir);
+ fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
+ endladdervirtualcoolingtubeshape[1],
+ fSSDAir);
+ fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
+ fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
+ fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
+ fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
}
///////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
// Deallocating memory
/////////////////////////////////////////////////////////////
delete [] vertexposition;
- delete xvertexpoints;
- delete yvertexpoints;
+ delete [] xvertexpoints;
+ delete [] yvertexpoints;
/////////////////////////////////////////////////////////////
return ssdcoolingblock;
}
/////////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
+void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
///////////////////////////////////////////////////////
- const Int_t kssdchipcablesnumber = 2;
- const Int_t kssdchipcableslaynumber = 2;
- const Int_t kvertexnumber = 4*(nedges+1)+4;
+ static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
+ static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
+ static const Int_t kvertexnumber = 4*(nedges+1)+4;
Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
Double_t ssdchipcablesradius[kssdchipcableslaynumber];
- ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
+ ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
- fgkSSDChipCablesHeight[0]
- fgkSSDChipCablesHeight[1]);
ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
TVector3* vertex = new TVector3();
TVector3* transvector[kssdchipcableslaynumber];
transvector[0] = new TVector3(fgkSSDChipWidth,
- SSDChipCablesHeigth-ssdchipcablesradius[0]);
+ SSDChipCablesHeight-ssdchipcablesradius[0]);
transvector[1] = new TVector3();
- TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
- TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
- const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
+ TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
+ TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
+ const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
{"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
"SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
for(Int_t k=0; k<kssdchipcablesnumber; k++){
+ fgkSSDChipCablesHeight[0]
+ fgkSSDChipCablesHeight[1]);
for(Int_t i=0; i<kssdchipcableslaynumber; i++){
- vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
+ vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
- fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
- vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
+ vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
- i*fgkSSDChipCablesHeight[0]);
vertexposition[i][2*(nedges+1)+2] =
new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
/////////////////////////////////////////////////////////////
// Mother Volume definition
/////////////////////////////////////////////////////////////
- Double_t ssdchipseparation = fgkSSDSensorLength
- - 2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
- - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
- Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
- Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
- +fgkSSDChipCablesWidth[1]
- +fgkSSDChipCablesWidth[2]);
- Double_t dy = fgkSSDChipCablesLength[1];
- Double_t dz = SSDChipCablesHeigth;
- TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
- TGeoVolumeAssembly* ssdchipcablesmother = new TGeoVolumeAssembly("SSDChipCablesMother");
-// TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
-// ssdchipcablesmotherbox,fSSDAir);
- /////////////////////////////////////////////////////////////
- // Rotation and Translation Definition for positioning
- /////////////////////////////////////////////////////////////
- TGeoRotation* ssdchipcablesrot[5];
- ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
- ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
- ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
- ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
- ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
- TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
- 0.,0.,ssdchipcablesrot[2]);
- ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
- ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
- ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
- ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
+ static const Int_t kmothervertexnumber = 8;
+ Double_t xmothervertex[kmothervertexnumber];
+ Double_t ymothervertex[kmothervertexnumber];
+ xmothervertex[0] = xvertexpoints[0][1];
+ ymothervertex[0] = yvertexpoints[0][1];
+ xmothervertex[1] = xvertexpoints[0][2+nedges/2];
+ ymothervertex[1] = yvertexpoints[0][1];
+ xmothervertex[2] = xvertexpoints[0][2+nedges/2];
+ ymothervertex[2] = yvertexpoints[0][2+nedges];
+ xmothervertex[3] = xvertexpoints[0][3+nedges];
+ ymothervertex[3] = yvertexpoints[0][3+nedges];
+ xmothervertex[4] = xvertexpoints[0][3+2*nedges];
+ ymothervertex[4] = yvertexpoints[0][3+2*nedges];
+ xmothervertex[5] = xvertexpoints[0][4+2*nedges];
+ ymothervertex[5] = yvertexpoints[0][4+2*nedges];
+ xmothervertex[6] = xvertexpoints[1][5+2*nedges];
+ ymothervertex[6] = yvertexpoints[1][5+2*nedges];
+ xmothervertex[7] = xvertexpoints[0][1];
+ ymothervertex[7] = yvertexpoints[1][5+2*nedges];
+ TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
+ ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
+ ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
+ ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
+
+ cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
+ cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
+
+ cableL->AddNode(ssdchipcable[0],1);
+ cableL->AddNode(ssdchipcable[1],1);
+ cableR->AddNode(ssdchipcable[2],1);
+ cableR->AddNode(ssdchipcable[3],1);
+
/////////////////////////////////////////////////////////////
// Deallocating memory
/////////////////////////////////////////////////////////////
for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
delete vertex;
- delete ssdchipcablesrot[0];
- delete ssdchipcablesrot[1];
- delete ssdchipcablesrot[3];
/////////////////////////////////////////////////////////////
- return ssdchipcablesmother;
}
-///////////////////////////////////////////////////////////////////////////////
-TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
- /////////////////////////////////////////////////////////////
- // SSD Chip Assembly
- /////////////////////////////////////////////////////////////
- TGeoVolume* ssdchipassembly = GetSSDChips();
- TList* ssdchipsystemlist = new TList();
-// 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]);
- }
- /////////////////////////////////////////////////////////////
- // SSD Chip Cables
- /////////////////////////////////////////////////////////////
- TGeoVolume* ssdchipcables[kchipsystemnumber];
- TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
- TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
- TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
- //////////////////
- for(Int_t i=0; i<kchipsystemnumber; i++){
- ssdchipcables[i] =
- GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
- ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
- ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
- ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
- }
- for(Int_t i=0; i<kchipsystemnumber; i++){
- for(Int_t j=0; j<fgkSSDChipNumber; j++){
- ssdchipcablestrans[i][j] = new TGeoTranslation();
- ssdchipcablesrot[i][j] = new TGeoRotation();
- ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
- ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
- ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
- + fgkSSDChipSeparationLength),
- 0.5*fgkSSDChipWidth,
- - 0.5*fgkSSDChipHeight
- - fgkSSDChipCablesHeight[i+2]);
- ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
- ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
- chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
- }
- chipsystemother[i]->AddNode(ssdchipassembly,i+1);
- ssdchipsystemlist->Add(chipsystemother[i]);
- }
- /////////////////////////////////////////////////////////////
- // Deallocating memory
- /////////////////////////////////////////////////////////////
- for(Int_t i=0; i<kchipsystemnumber; i++){
- for(Int_t j=0; j<fgkSSDChipNumber; j++){
- delete ssdchipcablesrot[i][j];
- delete ssdchipcablestrans[i][j];
- }
- delete ssdchipcablesrot[i];
- delete ssdchipcablestrans[i];
- }
- /////////////////////////////////////////////////////////////
- return ssdchipsystemlist;
-}
-///////////////////////////////////////////////////////////////////////////////
-TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
+//_____________________________________________________________________________
+TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
/////////////////////////////////////////////////////////////
// SSD Chip Assembly Generation
/////////////////////////////////////////////////////////////
- const Int_t kssdchiprownumber = 2;
TGeoBBox* ssdchipcompshape[2];
ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
0.5*fgkSSDChipLength,
TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
/////////////////////////////////////////////////////////////
for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
- Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
- fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
- - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
- - 0.5*fgkSSDChipWidth)};
- /////////////////////////////////////////////////////////////
- // Virtual Volume containing SSDChipAssembly
- /////////////////////////////////////////////////////////////
- TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
- const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
- Double_t xmothervertex[kssdmothervertexnumber];
- Double_t ymothervertex[kssdmothervertexnumber];
- ///////////////////////
- // Setting the vertices
- ///////////////////////
- xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
- xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
- - ymothervertex[0];
- xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
- ymothervertex[2] = ymothervertex[1];
- xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
- xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
- ymothervertex[4] = ymothervertex[0];
- xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
- xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
- + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
- ymothervertex[6] = ymothervertex[5];
- xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
- - fgkSSDChipWidth;
- xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
- ymothervertex[8] = ymothervertex[7];
- xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
- ymothervertex[9] = ymothervertex[6];
- xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
- xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
- //////////////////////////////////////////////////////////
- ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
- xmothervertex,ymothervertex);
- ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
- ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
-// TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
-// ssdchipmothershape,fSSDAir);
- TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer");
- /////////////////////////////////////////////////////////////
- for(Int_t i=0; i<kssdchiprownumber; i++)
- for(Int_t j=0; j<fgkSSDChipNumber; j++)
- ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
- new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
- return ssdchipmother;
+ return ssdchip;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
// Method returning a List containing pointers to Ladder Cable Volumes
+ //
+ // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
+ // each contains 2 volumes, one for polyamide and one for aluminium
/////////////////////////////////////////////////////////////
const Int_t kladdercablesegmentnumber = 2;
/////////////////////////////////////////
// LadderSegmentBBox Volume
/////////////////////////////////////////
- TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
+ static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
+
+
+ const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
+ {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
+ static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
+
+ static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
+ new TGeoTranslation("LadderCableSegmentBBoxTrans1",
+ 0.5*fgkSSDFlexWidth[0],
+ 0.5*fgkSSDLadderCableWidth,
+ 0.5*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 Assemblies
+ // Method generating Ladder Cable of given length (n modules + end)
+ // Called by GetLadderCableAssembly
/////////////////////////////////////////////////////////////
TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
- if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
+ if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
+
}
TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
- fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
- (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
+ fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
+ (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
return laddercable;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
- /////////////////////////////////////////////////////////////
- // Method generating Ladder Cable Volumes Assembly
- /////////////////////////////////////////////////////////////
- TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
- char laddercabletransname[30];
+ ///////////////////////////////////////////////////////////////////
+ // Main method generating Ladder Cable bundles containing n cables
+ ///////////////////////////////////////////////////////////////////
+ Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
+ Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])};
+ TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]),cableOrig);
+ TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
+ 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,
- new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
+ laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
+ new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
}
- return laddercableassembly;
+ return laddercable;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
/////////////////////////////////////////////////////////////
// Method generating Ladder Cable List Assemblies
+ // containing two cables bundles, i.e. P+N readout for one endcap
/////////////////////////////////////////////////////////////
- const Int_t kladdercableassemblynumber = 2;
+ const Int_t kladdercableassemblynumber = 2;
TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
TGeoVolume* ladderCable[kladdercableassemblynumber];
- char laddercableassemblyname[30];
+ char laddercableassemblyname[100];
TList* laddercableassemblylist = new TList();
for(Int_t i=0; i<kladdercableassemblynumber; i++){
sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
/////////////////////////////////////////////////////////////
fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
+
+ /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
+ TGeoXtru *laddersegmentshape = new TGeoXtru(2);
+ static const Int_t ntrianglevtx = 3;
+ Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
+ Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
+ laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
+ laddersegmentshape->DefineSection(0,0);
+ laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
+ fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
+ fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
+ */
+
if(!fCreateMaterials) CreateMaterials();
if(!fTransformationMatrices) CreateTransformationMatrices();
if(!fBasicObjects) CreateBasicObjects();
fcarbonfibersupportmatrix[j]);
}
// Placing Carbon Fiber Junction
- for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
+ for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
fcarbonfiberjunctionmatrix[j]);
+ }
// Placing Carbon Fiber Lower Support
- for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
+ for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
fcarbonfiberlowersupportrans[j]);
+ }
// Placing SSD Sensor Support
for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
- fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
+ fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
fssdsensorsupport[1][i],
j+1,fssdsensorsupportmatrix[j]);
// Placing SSD Cooling Tube Support
fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
fcoolingtubesupportmatrix[j]);
// Placing SSD Cooling Tube
- for(Int_t j=0; j<2; j++)
- for(Int_t k=0; k<2; k++){
- fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
- fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
- }
+ fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
+ fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
// Placing SSD Hybrid
switch(i){
case 0:
break;
}
// Placing Cooling Block System
- fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
+ fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
// Placing SSD Flex
- for(Int_t j=0; j<fgkflexnumber; j++){
- fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
- fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
- }
+ for(Int_t j=0; j<fgkflexnumber; j++){
+ fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
+ fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
+ }
}
}
///////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// End Ladder Cooling Tube Support
/////////////////////////////////////////////////////////////
-// fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
-// fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
- fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
- fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
- fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
- fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
- fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
- fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
- fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
- fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
+ fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
+ fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
}
///////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetLadder(){
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]);
}
/////////////////////////////////////////////////////////////////////////////
+ fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
TList* laddercableassemblylist[4];
const Int_t kendladdercablesnumber = 4;
+ TGeoRotation *laddercablerot = new TGeoRotation();
+ laddercablerot->SetAngles(90.,60.,-90.);
for(Int_t i=0; i<fgkladdercablesnumber; i++)
for(Int_t j=0; j<kendladdercablesnumber; j++){
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])));
ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
for(Int_t j=0; j<nedges+1; j++){
ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
- new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
- (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
+ new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
+ (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
}
}
Double_t **xmothervertex = new Double_t*[fgklayernumber];
////////////////////////////////////////////////////////////////////////////////
// Start Corrections 13/06/08
////////////////////////////////////////////////////////////////////////////////
- char lowerladderpconsupportname[30];
+ char lowerladderpconsupportname[100];
TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
TGeoVolume* lowerladderpconsupport[fgklayernumber];
Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
for(Int_t i=0; i<fgklayernumber; i++){
lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
* TMath::Cos(theta[i]);
- lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeigth;
+ lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
}
for(Int_t i=0; i<fgklayernumber; i++){
/////////////////////////// Modified Version ?///////////////////
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++)
const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
0.5*fgkEndCapCoverPlateThickness};
- TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
+ TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
nendcapcoverplateholedges,holesection);
TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
endcapcoverplatesmallhole->SetLineColor(6);
- TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
+ TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
nendcapcoverplateholedges,holesection);
TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
fSSDAlCoolBlockMedium);
endcapfillingbox->SetLineColor(6);
////////////////////////////
- // Contour Xtru Definition
+ // Contour shape Definition
////////////////////////////
const Int_t kcontourvertexnumber = 10;
Double_t xcontourvertex[kcontourvertexnumber];
+ fgkEndCapCoverPlateSmallHoleRadius;
ycontourvertex[8] = ycontourvertex[7];
ycontourvertex[9] = ycontourvertex[0];
- TGeoXtru* contourshape = new TGeoXtru(2);
- contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
- contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
- contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
+
+ Double_t xboxin, dxboxin, yboxin, dyboxin;
+ Double_t xboxout, dxboxout, yboxout, dyboxout;
+ Double_t coordmin, coordmax;
+ coordmin = -fgkEndCapCoverPlateLength[0];
+ coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
+ xboxout = 0.5*(coordmin+coordmax);
+ dxboxout = 0.5*(coordmax-coordmin);
+ coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
+ - (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]);
+ coordmax = (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
+ yboxout = 0.5*(coordmin+coordmax);
+ dyboxout = 0.5*(coordmax-coordmin);
+ coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
+ coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
+ xboxin = 0.5*(coordmin+coordmax);
+ dxboxin = 0.5*(coordmax-coordmin);
+ coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
+ coordmax = (kendcapcoverplatesmallholenumber[1]-1)
+ * fgkEndCapCoverPlateSmallHoleSeparation[2]
+ + fgkEndCapCoverPlateSmallHoleRadius;
+ yboxin = 0.5*(coordmin+coordmax);
+ dyboxin = 0.5*(coordmax-coordmin);
+ new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
+ TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
+ xboxout, yboxout, 0.);
+ trendCapCoverPlateContourboxout->RegisterYourself();
+ new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
+ TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
+ xboxin, yboxin, 0.);
+ trendCapCoverPlateContourboxin->RegisterYourself();
+ TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
+ "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
+
TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
fSSDAlCoolBlockMedium);
contour->SetLineColor(6);
/////////////////////////////
- // Hole Contour Xtru Definition
+ // Hole Contour Shape Definition
////////////////////////////
- const Int_t kholecontourvertexnumber = 10;
+ coordmin = xcontourvertex[0];
+ coordmax = coordmin+fgkEndCapCoverPlateLength[2];
+ xboxout = 0.5*(coordmin+coordmax);
+ dxboxout = 0.5*(coordmax-coordmin);
+ coordmin = ycontourvertex[1];
+ coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
+ yboxout = 0.5*(coordmin+coordmax);
+ dyboxout = 0.5*(coordmax-coordmin);
+ coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
+ xboxin = 0.5*(coordmin+coordmax);
+ dxboxin = 0.5*(coordmax-coordmin);
+ coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);;
+ coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
+ yboxin = 0.5*(coordmin+coordmax);
+ dyboxin = 0.5*(coordmax-coordmin);
+ new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
+ TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
+ xboxout, yboxout, 0.);
+ trendCapCoverPlateContourboxout1->RegisterYourself();
+ new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
+ TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
+ xboxin, yboxin, 0.);
+ trendCapCoverPlateContourboxin1->RegisterYourself();
+ TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
+ "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
+
+
+ coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
+ coordmax = coordmin+fgkEndCapCoverPlateLength[2];
+ xboxout = 0.5*(coordmin+coordmax);
+ dxboxout = 0.5*(coordmax-coordmin);
+ coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]);
+ coordmax = ycontourvertex[0];
+ yboxout = 0.5*(coordmin+coordmax);
+ dyboxout = 0.5*(coordmax-coordmin);
+ coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
+ xboxin = 0.5*(coordmin+coordmax);
+ dxboxin = 0.5*(coordmax-coordmin);
+ coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
+ - fgkEndCapCoverPlateWidth[0]
+ - 2.*fgkEndCapCoverPlateBigHoleRadius);
+ coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
+ yboxin = 0.5*(coordmin+coordmax);
+ dyboxin = 0.5*(coordmax-coordmin);
+ new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
+ TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
+ xboxout, yboxout, 0.);
+ trendCapCoverPlateContourboxout2->RegisterYourself();
+ new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
+ TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
+ xboxin, yboxin, 0.);
+ trendCapCoverPlateContourboxin2->RegisterYourself();
+ TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
+ "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
+
+// const Int_t kholecontourvertexnumber = 10;
+
Double_t xholecontourvertex[2][kcontourvertexnumber];
Double_t yholecontourvertex[2][kcontourvertexnumber];
xholecontourvertex[0][0] = xcontourvertex[0];
yholecontourvertex[1][8] = yholecontourvertex[1][7];
yholecontourvertex[1][9] = yholecontourvertex[1][0];
- TGeoXtru* holecontourshape[2];
- holecontourshape[0] = new TGeoXtru(2);
- holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
- yholecontourvertex[0]);
- holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
- holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
-
- holecontourshape[1] = new TGeoXtru(2);
- holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
- yholecontourvertex[1]);
- holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
- holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
-
TGeoVolume* holecontour[2];
- holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
+ holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
fSSDAlCoolBlockMedium);
holecontour[0]->SetLineColor(6);
- holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
+ holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
fSSDAlCoolBlockMedium);
holecontour[1]->SetLineColor(6);
TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
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);
yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
yvertex[13] = yvertex[12];
yvertex[14] = yvertex[6];
- TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
- endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
- endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
- endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
+ TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
+ endcapsidecovershapeout->SetName("endcapsidecovershapeout");
+ endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
+ endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
+ endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
+ TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
+ endcapsidecovershapein->SetName("endcapsidecovershapein");
+ endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
+ endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
+ endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
+
+
+ TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
endcapsidecovershape,fSSDCoolingTubePhynox);
endcapsidecover->SetLineColor(fColorPhynox);
Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
fgkEndCapCoverPlateThickness
+ fgkEndCapCoolingTubeRadiusMax};
- TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
+ TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
screwcoverplatedgesnumber,
screwcoverplatesection);
TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
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();
Double_t ssdcablepatchpanel3BB26radiusmin[2];
Double_t ssdcablepatchpanel3BB26radiusmax[2];
Double_t ssdcablepatchpanel3RB26zsection[2];
- ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth+2.8;
+ ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
+ 0.*fgkSSDCablesLay5RightSideHeight
- + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
+ fgkSSDCentralAL3SupportLength
+ fgkSSDPConeZLength[0];
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();
+ fgkSSDCentralAL3SupportLength
+ (4.0/5.0)*fgkSSDPConeZLength[0];
ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
- ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
+ ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
TGeoPcon* ssdcableitsring3BB26pconshape[4];
ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
+ 0.*fgkSSDCablesLay5RightSideHeight
+ 0.*fgkSSDCablesLay6RightSideHeight
- + 0.5*fgkSSDPatchPanelHeigth;
+ + 0.5*fgkSSDPatchPanelHeight;
ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
- fgkSSDCentralAL3SupportLength
- fgkSSDPConeZLength[0];
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]);
Double_t ssdcableitsring3BB24pconrmax[2];
ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
- ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
+ ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
+ fgkSSDCablesLay5RightSideHeight
- + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
+ + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
TGeoPcon* ssdcableitsring3BB24pconshape[4];
}
////////////////////////////////////////////////////////////////////////////////
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;
}
///////////////////////////////////////////////////////////////////////////////
return arcshape;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
+TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
///////////////////////////////////////////////////////////////////////
// Method Generating the Screw Shape
// radius[0]: outer radius
Double_t inradius = radius[1];
Int_t outvertexnumber = edgesnumber[0];
Int_t invertexnumber = edgesnumber[1];
- Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
- Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
- for(Int_t i=0; i<outvertexnumber+1; i++){
+ Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
+ Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
+ for(Int_t i=0; i<outvertexnumber; i++){
xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
}
- for(Int_t i=0; i<invertexnumber+1; i++){
- xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
- yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
+ for(Int_t i=0; i<invertexnumber; i++){
+ xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
+ yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
}
- TGeoXtru* screwshape = new TGeoXtru(2);
- screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
- screwshape->DefineSection(0,section[0]);
- screwshape->DefineSection(1,section[1]);
+ TGeoXtru* screwshapeout = new TGeoXtru(2);
+ screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
+ screwshapeout->DefineSection(0,section[0]);
+ screwshapeout->DefineSection(1,section[1]);
+ TGeoXtru* screwshapein = new TGeoXtru(2);
+ screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
+ screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
+ screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
+ TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
+ TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
+
delete [] xscrewvertex;
delete [] yscrewvertex;
return screwshape;
}
////////////////////////////////////////////////////////////////////////////////
-TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
+TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
///////////////////////////////////////////////////////////////////////
// Method Generating the Hole Shape
// radius of the Hole
// nedges: number of edges to approximate the circle
///////////////////////////////////////////////////////////////////////
- Int_t vertexnumber = nedges+6;
- Double_t* xholevertex = new Double_t[vertexnumber];
- Double_t* yholevertex = new Double_t[vertexnumber];
- xholevertex[0] = radius;
- xholevertex[1] = xholevertex[0];
- xholevertex[2] = -xholevertex[1];
- xholevertex[3] = xholevertex[2];
- xholevertex[4] = xholevertex[0];
- yholevertex[0] = 0.;
- yholevertex[1] = -radius;
- yholevertex[2] = yholevertex[1];
- yholevertex[3] = -yholevertex[1];
- yholevertex[4] = yholevertex[3];
- for(Int_t i=0; i<nedges+1; i++){
- xholevertex[i+5] = radius*CosD(i*360./nedges);
- yholevertex[i+5] = radius*SinD(i*360./nedges);
+ Double_t* xholevertex = new Double_t[nedges];
+ Double_t* yholevertex = new Double_t[nedges];
+ Double_t z = 0.5*(section[0]+section[1]);
+ Double_t dz = 0.5*(section[1]-section[0]);
+ TGeoTranslation *tr = 0;
+ if (TMath::Abs(z) > TGeoShape::Tolerance()) {
+ tr = new TGeoTranslation(0.,0.,z);
+ tr->RegisterYourself();
+ }
+ TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
+ for(Int_t i=0; i<nedges; i++){
+ xholevertex[i] = radius*CosD(i*360./nedges);
+ yholevertex[i] = radius*SinD(i*360./nedges);
}
- TGeoXtru* holeshape = new TGeoXtru(2);
- holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
- holeshape->DefineSection(0,section[0]);
- holeshape->DefineSection(1,section[1]);
+ TGeoXtru* holeshapeout = new TGeoXtru(2);
+ holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
+ holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
+ holeshapeout->DefineSection(1,section[1]+0.01);
+ TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
+ TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
+
delete [] xholevertex;
delete [] yholevertex;
return holeshape;
/////////////////////////////////////////////////////////////
// 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;
}
/////////////////////////////////////////////////////////////////////
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff