ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
AFP_GeoModelFactory Class Reference

#include <AFP_GeoModelFactory.h>

Inheritance diagram for AFP_GeoModelFactory:
Collaboration diagram for AFP_GeoModelFactory:

Public Member Functions

 AFP_GeoModelFactory (StoreGateSvc *pDetStore, AFP_Geometry *pGeometry)
 
 ~AFP_GeoModelFactory ()
 
virtual void create (GeoPhysVol *world)
 
virtual const AFP_GeoModelManager * getDetectorManager () const
 
void updatePositions (AFP_BPMCOOLPARAMS *pBpmParams)
 

Private Member Functions

void defineMaterials ()
 
const AFP_GeoModelFactory & operator= (const AFP_GeoModelFactory &right)
 
 AFP_GeoModelFactory (const AFP_GeoModelFactory &right)
 
GeoShape * createSolidSIDPlate ()
 
void addSiDetector (GeoPhysVol *pPhysMotherVol, const char *pszStationName, HepGeom::Transform3D &TransInMotherVolume)
 
void addRomanPot (GeoPhysVol *pPhysMotherVol, const char *pszStationName, HepGeom::Transform3D &TransInMotherVolume)
 
void initializeTDParameters ()
 
StatusCode addTimingDetector (const char *pszStationName, GeoOpticalPhysVol *pPhysMotherVol, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
void addLQBarSegment (const char *pszStationName, const int nQuarticID, const int nLQBarID, AFPTOF_LBARDIMENSIONS &LQBarDims, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
void addSepRadLBar (const char *pszStationName, const int nQuarticID, const int nBarID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
HepGeom::Vector3D< double > getBarShift (AFPTOF_LBARDIMENSIONS &LQBarDims, eLBarType eSpecType=ELBT_UNDEFINED)
 
void addHorizontalArm (const char *pszStationName, const int nQuarticID, const int nLQBarID, AFPTOF_LBARDIMENSIONS &LQBarDims, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &PartialTransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
void addSensor (const char *pszStationName, const int nQuarticID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
void addLBarSensorSeparationWindow (const char *pszStationName, const int nQuarticID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
 
void getLQBarDimensions (const int nRowID, const int nColID, AFPTOF_LBARDIMENSIONS *pLQBarDims)
 

Private Attributes

std::map< std::string, GeoRef< const GeoMaterial > > m_MapMaterials
 
AFP_GeoModelManager * m_pDetectorManager
 
StoreGateSvc * m_pDetectorStore
 
std::map< std::string, const GeoShape * > m_MapShape
 
AFP_CONFIGURATION m_CfgParams
 
AFP_Geometry * m_pGeometry
 
const bool m_addSeparationWindow
 
GeoOpticalSurface * m_pOpticalSurface = nullptr
 
GeoOpticalSurface * m_pReflectionOptSurface = nullptr
 

Detailed Description

Definition at line 29 of file AFP_GeoModelFactory.h.

Constructor & Destructor Documentation

◆ AFP_GeoModelFactory() [1/2]

AFP_GeoModelFactory::AFP_GeoModelFactory ( StoreGateSvc *  pDetStore,
AFP_Geometry *  pGeometry 
)

Definition at line 44 of file AFP_GeoModelFactory.cxx.

45  :m_pDetectorManager(nullptr), m_pDetectorStore(detStore), m_addSeparationWindow(false)
46 {
47  pGeometry->getCfgParams(&m_CfgParams);
48  m_pGeometry=pGeometry;
49 
50  initializeTDParameters();
51 }

◆ ~AFP_GeoModelFactory()

AFP_GeoModelFactory::~AFP_GeoModelFactory ( )

Definition at line 54 of file AFP_GeoModelFactory.cxx.

55 {
56  m_CfgParams.clear();
57 }

◆ AFP_GeoModelFactory() [2/2]

AFP_GeoModelFactory::AFP_GeoModelFactory ( const AFP_GeoModelFactory &  right)
private

Member Function Documentation

◆ addHorizontalArm()

void AFP_GeoModelFactory::addHorizontalArm ( const char *  pszStationName,
const int  nQuarticID,
const int  nLQBarID,
AFPTOF_LBARDIMENSIONS &  LQBarDims,
GeoOpticalPhysVol *  pPhysMotherVolume,
HepGeom::Transform3D &  PartialTransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

◆ addLBarSensorSeparationWindow()

void AFP_GeoModelFactory::addLBarSensorSeparationWindow ( const char *  pszStationName,
const int  nQuarticID,
GeoOpticalPhysVol *  pPhysMotherVolume,
HepGeom::Transform3D &  TransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

Definition at line 214 of file AFP_GeoModelTD.cxx.

216 {
217  int nPixelID;
218  char szlabel[64];
219  double fX1Pos_1, fX2Pos_1, fX1Pos_2, fX2Pos_2;
220  HepGeom::Transform3D TotTransform;
221 
222  eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
223  AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
224  double fSensor2BarDistance=(TofCfg.bEmulateImmersion)? 0.0:AFP_CONSTANTS::ToF_Sensor2BarDist;
225 
226  GeoTube* pSolWindow=new GeoTube(0,0.5*AFP_CONSTANTS::ToF_SeparationWindowDiameter,0.5*AFP_CONSTANTS::ToF_SeparationWindowThickness);
227 
228  nPixelID=10*( TofCfg.nX1PixCnt/2-1 +1)+( TofCfg.nX1PixCnt/2-1 +1);
229  m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos_1,&fX2Pos_1);
230  nPixelID=10*( TofCfg.nX1PixCnt/2 +1)+( TofCfg.nX1PixCnt/2 +1);
231  m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos_2,&fX2Pos_2);
232 
233  sprintf(szlabel,"%s_Q%i_LogLBarSensorSeparationWindow",pszStationName,nQuarticID);
234  TotTransform=TransInMotherVolume*HepGeom::Translate3D(0.5*(fX1Pos_1+fX1Pos_2),-0.5*AFP_CONSTANTS::ToF_SeparationWindowThickness-fSensor2BarDistance,0.5*(fX2Pos_1+fX2Pos_2))*HepGeom::RotateX3D(90.0*CLHEP::deg);
235  GeoLogVol* pLogWindow=new GeoLogVol(szlabel,pSolWindow,m_MapMaterials["Quartz"]);
236  GeoOpticalPhysVol* pPhysWindow=new GeoOpticalPhysVol(pLogWindow);
237  sprintf(szlabel,"%s_Q%i_LBarSensorSeparationWindow",pszStationName,nQuarticID);
238  pPhysMotherVolume->add(new GeoNameTag(szlabel));
239  pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
240  pPhysMotherVolume->add(pPhysWindow);
241  sprintf(szlabel,"%s_Q%i_WindowSurface",pszStationName,nQuarticID);
242  bsContainer->push_back(GeoBorderSurface(szlabel, pPhysWindow, pPhysMotherVolume, m_pOpticalSurface));
243 
244  pPhysWindow=nullptr;
245 
246 }

◆ addLQBarSegment()

void AFP_GeoModelFactory::addLQBarSegment ( const char *  pszStationName,
const int  nQuarticID,
const int  nLQBarID,
AFPTOF_LBARDIMENSIONS &  LQBarDims,
GeoOpticalPhysVol *  pPhysMotherVolume,
HepGeom::Transform3D &  TransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

◆ addRomanPot()

void AFP_GeoModelFactory::addRomanPot ( GeoPhysVol *  pPhysMotherVol,
const char *  pszStationName,
HepGeom::Transform3D &  TransInMotherVolume 
)
private

Definition at line 60 of file AFP_GeoModelRP.cxx.

61 {
62  const double fMainTubusSteelPartLength=RPOT_MAINTUBUS_LENGTH-RPOT_MAINTUBUS_FLOORPARTLENGTH;
63 
64  char szLabel[32];
65  double fLength,fRMin,fRMax;
66  GeoShapeShift* pMoveCut;
67  GeoShape* pSolCut;
68 
69  HepGeom::Transform3D TransRPot=TransInMotherVolume*HepGeom::TranslateX3D(-(0.5*fMainTubusSteelPartLength+RPOT_MAINTUBUS_FLOORPARTLENGTH+RPOT_FLOOR_WNDTHICKNESS));
70 
71  //Main tubus -------------------------------------------------------------------------------------------------
72  fLength=fMainTubusSteelPartLength;
73  fRMin=RPOT_MAINTUBUS_INNERRADIUS;
74  fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
75 
76  GeoTube* pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
77  sprintf(szLabel,"%s_LogRPMainTubus",pszStationName);
78  GeoLogVol* pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]);
79  sprintf(szLabel,"%s_RPMainTubus",pszStationName);
80  GeoFullPhysVol* pPhysTubus=new GeoFullPhysVol(pLogTubus);
81  pPhysMotherVol->add(new GeoNameTag(szLabel));
82  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::RotateY3D(90*CLHEP::deg))));
83  pPhysMotherVol->add(pPhysTubus);
84 
85  //Main tubus - floor (bottom) part ---------------------------------------------------------------------------
86  fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
87  fRMin=RPOT_MAINTUBUS_INNERRADIUS;
88  fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
89 
90  sprintf(szLabel,"%s_LogRPMainTubusFloorPart",pszStationName);
91  pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
92  sprintf(szLabel,"%s_LogRPMainTubusFloorPart",pszStationName);
93  pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]); //XXX
94  pPhysTubus=new GeoFullPhysVol(pLogTubus);
95  sprintf(szLabel,"%s_RPMainTubusFloorPart",pszStationName);
96  pPhysMotherVol->add(new GeoNameTag(szLabel));
97  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
98  pPhysMotherVol->add(pPhysTubus);
99 
100  //--upper mass
101  fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
102  fRMin=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
103  fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
104  double fPhi=asin(0.5*RPOT_FLOOR_WNDWIDTH/fRMin);
105  double fDPhi=CLHEP::pi-2*fPhi;
106  GeoTubs* pSolMass=new GeoTubs(fRMin,fRMax,0.5*fLength,fPhi,fDPhi);
107 
108  sprintf(szLabel,"%s_LogRPMainTubusUMass",pszStationName);
109  pLogTubus=new GeoLogVol(szLabel,pSolMass,m_MapMaterials[std::string("Steel_AFP")]); //XXX
110  pPhysTubus=new GeoFullPhysVol(pLogTubus);
111  sprintf(szLabel,"%s_LogRPMainTubusUMass",pszStationName);
112  pPhysMotherVol->add(new GeoNameTag(szLabel));
113  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
114  pPhysMotherVol->add(pPhysTubus);
115 
116  //-lower mass
117  fLength=RPOT_MAINTUBUS_FLOORPARTLENGTH;
118  fRMin=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_BPTHICKNESS;
119  fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
120  double fSPhi=CLHEP::pi+fPhi;
121  pSolMass=new GeoTubs(fRMin,fRMax,0.5*fLength,fSPhi,fDPhi);
122 
123  sprintf(szLabel,"%s_LogRPMainTubusLMass",pszStationName);
124  pLogTubus=new GeoLogVol(szLabel,pSolMass,m_MapMaterials[std::string("Steel_AFP")]); //XXX
125  pPhysTubus=new GeoFullPhysVol(pLogTubus);
126  sprintf(szLabel,"%s_LogRPMainTubusLMass",pszStationName);
127  pPhysMotherVol->add(new GeoNameTag(szLabel));
128  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fLength+0.5*fMainTubusSteelPartLength)*HepGeom::RotateY3D(90*CLHEP::deg))));
129  pPhysMotherVol->add(pPhysTubus);
130 
131 
132  //Floor tubus -------------------------------------------------------------------------------------------------
133  fLength=RPOT_FLOOR_THICKNESS;
134  fRMin=0.0*CLHEP::mm;
135  fRMax=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS-RPOT_MAINTUBUS_WNDTHICKNESS;
136  pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
137 
138  //cut volume
139  double fTrdHXLength1=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
140  double fTrdHXLength2=RPOT_MAINTUBUS_INNERRADIUS+RPOT_MAINTUBUS_THICKNESS;
141  double fTrdHYLength2=0.5*RPOT_FLOOR_WNDWIDTH;
142  double fTrdHYLength1=0.5*RPOT_FLOOR_WNDWIDTH-RPOT_FLOOR_WNDTHICKNESS*tan(RPOT_FLOOR_WNDFACET);
143  double fTrdHZLength=0.5*(RPOT_FLOOR_THICKNESS-RPOT_FLOOR_WNDTHICKNESS);
144  pSolCut=new GeoTrd(fTrdHXLength1,fTrdHXLength2,fTrdHYLength1,fTrdHYLength2,fTrdHZLength);
145  GeoTrf::Transform3D TransCut=GeoTrf::TranslateZ3D(0.5*fLength-fTrdHZLength);
146  pMoveCut=new GeoShapeShift(pSolCut, TransCut);
147  GeoShapeSubtraction* pSolFloor=new GeoShapeSubtraction(pSolTubus, pMoveCut);
148 
149  sprintf(szLabel,"%s_LogRPFloorTubus",pszStationName);
150  pLogTubus=new GeoLogVol(szLabel,pSolFloor,m_MapMaterials[std::string("Beryllium_AFP")]);
151  pPhysTubus=new GeoFullPhysVol(pLogTubus);
152  sprintf(szLabel,"%s_RPFloorTubus",pszStationName);
153  pPhysMotherVol->add(new GeoNameTag(szLabel));
154  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(0.5*fMainTubusSteelPartLength+RPOT_MAINTUBUS_FLOORPARTLENGTH+0.5*RPOT_FLOOR_THICKNESS)*HepGeom::RotateY3D(90*CLHEP::deg))));
155  pPhysMotherVol->add(pPhysTubus);
156 
157  //Flange tubus -------------------------------------------------------------------------------------------------
158  fLength=RPOT_FLANGE_THICKNESS;
159  fRMin=RPOT_MAINTUBUS_INNERRADIUS;
160  fRMax=RPOT_FLANGE_OUTERRADIUS;
161 
162  pSolTubus=new GeoTube(fRMin, fRMax, 0.5*fLength);
163  sprintf(szLabel,"%s_LogRPFlangeTubus",pszStationName);
164  pLogTubus=new GeoLogVol(szLabel,pSolTubus,m_MapMaterials[std::string("Steel_AFP")]);
165  pPhysTubus=new GeoFullPhysVol(pLogTubus);
166  sprintf(szLabel,"%s_RPFlangeTubus",pszStationName);
167  pPhysMotherVol->add(new GeoNameTag(szLabel));
168  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransRPot*HepGeom::TranslateX3D(-0.5*fMainTubusSteelPartLength-0.5*RPOT_FLANGE_THICKNESS)*HepGeom::RotateY3D(90*CLHEP::deg))));
169  pPhysMotherVol->add(pPhysTubus);
170 
171 }

◆ addSensor()

void AFP_GeoModelFactory::addSensor ( const char *  pszStationName,
const int  nQuarticID,
GeoOpticalPhysVol *  pPhysMotherVolume,
HepGeom::Transform3D &  TransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

Definition at line 250 of file AFP_GeoModelTD.cxx.

252 {
253  int i,j,nPixelID;
254  char szlabel[64];
255  double fX1Pos, fX2Pos;
256  HepGeom::Transform3D TotTransform;
257 
258  eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
259  AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
260  double fSensor2BarDistance=(TofCfg.bEmulateImmersion)? 0.0:AFP_CONSTANTS::ToF_Sensor2BarDist;
261  if(m_addSeparationWindow)
262  {
263  fSensor2BarDistance += AFP_CONSTANTS::ToF_SeparationWindowThickness;
264  }
265 
266  GeoBox* pSolSensor=new GeoBox(0.5*TofCfg.fPixelX1Dim,0.5*AFP_CONSTANTS::ToF_SensorThickness,0.5*TofCfg.fPixelX2Dim);
267 
268  for(i=0;i<TofCfg.nX1PixCnt;i++)
269  {
270  for(j=0;j<TofCfg.nX2PixCnt;j++)
271  {
272  nPixelID=10*(i+1)+(j+1);
273  m_pGeometry->getPixelLocalPosition(eStation,nPixelID,&fX1Pos,&fX2Pos);
274 
275  sprintf(szlabel,"%s_Q%i_LogTDSensor[%i]",pszStationName,nQuarticID,nPixelID);
276  TotTransform=TransInMotherVolume*HepGeom::Translate3D(fX1Pos,-0.5*AFP_CONSTANTS::ToF_SensorThickness-fSensor2BarDistance,fX2Pos);
277  GeoLogVol* pLogSensor=new GeoLogVol(szlabel,pSolSensor,m_MapMaterials["SiliconPMT"]);
278  GeoOpticalPhysVol* pPhysSensor=new GeoOpticalPhysVol(pLogSensor);
279  sprintf(szlabel,"%s_Q%i_TDSensor[%i]",pszStationName,nQuarticID,nPixelID);
280  pPhysMotherVolume->add(new GeoNameTag(szlabel));
281  pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
282  pPhysMotherVolume->add(pPhysSensor);
283  sprintf(szlabel,"%s_Q%i_SensorSurface[%i]",pszStationName,nQuarticID,nPixelID);
284  bsContainer->push_back(GeoBorderSurface(szlabel, pPhysSensor, pPhysMotherVolume, m_pOpticalSurface));
285 
286  pPhysSensor=nullptr;
287  }
288  }
289 
290 }

◆ addSepRadLBar()

void AFP_GeoModelFactory::addSepRadLBar ( const char *  pszStationName,
const int  nQuarticID,
const int  nBarID,
GeoOpticalPhysVol *  pPhysMotherVolume,
HepGeom::Transform3D &  TransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

Definition at line 95 of file AFP_GeoModelTD.cxx.

96 {
97  double fX1Pos,fX2Pos,falpha,fd;
98  HepGeom::Vector3D<double> vecA1, vecA2, vecX;
99  CLHEP::Hep3Vector vecCutShift;
100  HepGeom::Transform3D TransCut;
101  GeoShapeShift* pMoveCut;
102  GeoBox* pSolAux;
103  char szlabel[64];
104 
105  CLHEP::HepRotation Rot1,Rot2,Rot3;
106 
107  eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
108  AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
109  AFPTOF_LBARDIMENSIONS BarDims=TofCfg.mapBarDims[nBarID];
110 
111  double fTaperOffset=TofCfg.mapTrainInfo[BarDims.nTrainID].fTaperOffset;
112  m_pGeometry->getPixelLocalPosition(eStation,nBarID,&fX1Pos,&fX2Pos);
113 
114  fX1Pos+=TofCfg.mapTrainInfo[BarDims.nTrainID].fPerpShiftInPixel;
115 
116 
117  //Light guide
118  HepGeom::Transform3D TotTransform=TransInMotherVolume*HepGeom::Translate3D( fX1Pos,
119  0.5*BarDims.fLGuideLength,
120  fX2Pos);
121  GeoShape* pSolVolume=new GeoBox(0.5*BarDims.fLGuideWidth,0.5*BarDims.fLGuideLength,0.5*BarDims.fLBarThickness);
122 
123  if(TofCfg.mapTrainInfo[BarDims.nTrainID].bUseTaper)
124  {
125  falpha=TofCfg.mapTrainInfo[BarDims.nTrainID].fTaperAngle;
126  fd=fTaperOffset/std::sin(falpha);
127  vecA1=-fd*std::cos(falpha)*CLHEP::Hep3Vector(0.0,1.0,0.0);
128  vecA2=+0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationZ(+(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(0.0,1.0,0.0)).unit();
129  vecX=vecA1+vecA2;
130  vecCutShift=CLHEP::Hep3Vector(-0.5*BarDims.fLGuideWidth,0.5*BarDims.fLGuideLength,0.0)+CLHEP::Hep3Vector(vecX);
131  Rot1.rotateZ(-falpha);
132 
133  pSolAux=new GeoBox(0.5*fd,0.5*fd,0.5*BarDims.fLBarThickness+SLIMCUT);
134  TransCut=HepGeom::Transform3D(Rot1,vecCutShift);
135  pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
136  pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
137  }
138 
139  sprintf(szlabel,"%s_Q%i_LogLGuide[%i]",pszStationName,nQuarticID,nBarID);
140  GeoLogVol* pLogLGuide=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
141  GeoOpticalPhysVol* pPhysLGuide=new GeoOpticalPhysVol(pLogLGuide);
142  sprintf(szlabel,"%s_Q%i_LGuide[%i]",pszStationName,nQuarticID,nBarID);
143  pPhysMotherVolume->add(new GeoNameTag(szlabel));
144  pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
145  pPhysMotherVolume->add(pPhysLGuide);
146  sprintf(szlabel,"%s_Q%i_LGuideSurface[%i]",pszStationName,nQuarticID,nBarID);
147  bsContainer->push_back(GeoBorderSurface(szlabel, pPhysLGuide, pPhysMotherVolume, m_pOpticalSurface));
148 
149  //Radiator elbow
150  double fRadYDim=BarDims.fRadYDim;
151  double fElbowXDim=fRadYDim;
152  TotTransform=TransInMotherVolume*HepGeom::Translate3D( fX1Pos-0.5*BarDims.fLGuideWidth+0.5*fElbowXDim+fTaperOffset,
153  BarDims.fLGuideLength+0.5*fRadYDim,
154  fX2Pos);
155  pSolVolume=new GeoBox(0.5*fElbowXDim,0.5*fRadYDim,0.5*BarDims.fLBarThickness);
156 
157  falpha=45.0*CLHEP::deg;
158  fd=fRadYDim/std::sin(falpha);//std::sqrt(2.0)*fRadYDim;
159  vecA1=-fd*std::cos(falpha)*CLHEP::Hep3Vector(0.0,1.0,0.0);
160  vecA2=+0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationZ(+(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(0.0,1.0,0.0)).unit();
161  vecX=vecA1+vecA2;
162  vecCutShift=CLHEP::Hep3Vector(-0.5*fElbowXDim,0.5*fRadYDim,0.0)+CLHEP::Hep3Vector(vecX);
163  Rot2.rotateZ(-falpha);
164 
165  pSolAux=new GeoBox(0.5*fd,0.5*fd,0.5*BarDims.fLBarThickness+SLIMCUT);
166  TransCut=HepGeom::Transform3D(Rot2,vecCutShift);
167  pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
168  pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
169 
170  sprintf(szlabel,"%s_Q%i_LogRadiator[%i]",pszStationName,nQuarticID,nBarID);
171  GeoLogVol* pLogRadiator=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
172  GeoOpticalPhysVol* pPhysRadiator=new GeoOpticalPhysVol(pLogRadiator);
173  sprintf(szlabel,"%s_Q%i_Radiator[%i]",pszStationName,nQuarticID,nBarID);
174  pPhysMotherVolume->add(new GeoNameTag(szlabel));
175  pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
176  pPhysMotherVolume->add(pPhysRadiator);
177  sprintf(szlabel,"%s_Q%i_RadiatorElbowSurface[%i]",pszStationName,nQuarticID,nBarID);
178  bsContainer->push_back(GeoBorderSurface(szlabel, pPhysRadiator, pPhysMotherVolume, m_pReflectionOptSurface));
179 
180  //Radiator
181  double fRadLength=BarDims.fRadLength-(BarDims.fLGuideWidth-fTaperOffset);
182  TotTransform=TransInMotherVolume*HepGeom::Translate3D( fX1Pos-0.5*BarDims.fLGuideWidth+fElbowXDim+fTaperOffset+0.5*fRadLength,
183  BarDims.fLGuideLength+0.5*fRadYDim,
184  fX2Pos);
185  pSolVolume=new GeoBox(0.5*fRadLength,0.5*fRadYDim,0.5*BarDims.fLBarThickness);
186 
187  if(TofCfg.bApplyBottomCut){
188  falpha = TofCfg.fAlpha;
189  fd = BarDims.fLBarThickness/std::sin(falpha);
190  vecA1 = -fd*std::cos(falpha)*CLHEP::Hep3Vector(1.0,0.0,0.0);
191  vecA2 = 0.5*fd*std::sqrt(2.0)*(CLHEP::HepRotationY(-(45*CLHEP::deg-falpha))*CLHEP::Hep3Vector(1.0,0.0,0.0)).unit();
192  vecX = vecA1 + vecA2;
193  vecCutShift = CLHEP::Hep3Vector(0.5*fRadLength,0.0,0.5*BarDims.fLBarThickness) + CLHEP::Hep3Vector(vecX);
194  Rot3.rotateY(falpha);
195 
196  pSolAux=new GeoBox(0.5*fd,0.5*fRadYDim+SLIMCUT,0.5*fd);
197  TransCut=HepGeom::Transform3D(Rot3,vecCutShift);
198  pMoveCut=new GeoShapeShift(pSolAux, Amg::CLHEPTransformToEigen(TransCut));
199  pSolVolume=new GeoShapeSubtraction(pSolVolume, pMoveCut);
200  }
201 
202  sprintf(szlabel,"%s_Q%i_LogRadiator[%i]",pszStationName,nQuarticID,nBarID);
203  pLogRadiator=new GeoLogVol(szlabel,pSolVolume,m_MapMaterials[std::string("Quartz")]);
204  pPhysRadiator=new GeoOpticalPhysVol(pLogRadiator);
205  sprintf(szlabel,"%s_Q%i_Radiator[%i]",pszStationName,nQuarticID,nBarID);
206  pPhysMotherVolume->add(new GeoNameTag(szlabel));
207  pPhysMotherVolume->add(new GeoTransform(Amg::CLHEPTransformToEigen(TotTransform)));
208  pPhysMotherVolume->add(pPhysRadiator);
209  sprintf(szlabel,"%s_Q%i_RadiatorSurface[%i]",pszStationName,nQuarticID,nBarID);
210  bsContainer->push_back(GeoBorderSurface(szlabel, pPhysRadiator, pPhysMotherVolume, m_pOpticalSurface));
211 }

◆ addSiDetector()

void AFP_GeoModelFactory::addSiDetector ( GeoPhysVol *  pPhysMotherVol,
const char *  pszStationName,
HepGeom::Transform3D &  TransInMotherVolume 
)
private

Definition at line 42 of file AFP_GeoModelSID.cxx.

43 {
44  char szLabel[32];
45  GeoLogVol* pLogElement=nullptr;
46  GeoFullPhysVol* pPhysElement;
47  eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
48  AFP_SIDCONFIGURATION sidcfg=m_CfgParams.sidcfg[eStation];
49 
50  //create (constant) solids
51  GeoShape* pSolidSIDPlate=createSolidSIDPlate();
52  GeoShape* pSolidSIDSensor=new GeoBox(0.5*AFP_CONSTANTS::SiT_Pixel_length_totx,0.5*AFP_CONSTANTS::SiT_Pixel_length_toty,0.5*AFP_CONSTANTS::SiT_Pixel_thickness);
53  GeoShape* pSolidSIDVacuumSensor=new GeoBox(0.5*180.0*CLHEP::mm,0.5*160.0*CLHEP::mm,0.5*AFP_CONSTANTS::Stat_GlobalVacuumSensorThickness);
54 
55  //add global vacuum sensitive volume (ID=11)
56  int nSpecVacSensorID=AFP_CONSTANTS::Stat_GlobalVacuumSensorID;
57  sprintf(szLabel,"%s_LogSIDVacuumSensor[%i]",pszStationName,nSpecVacSensorID);
58  GeoLogVol* pLogSIDVacuumSensor=new GeoLogVol(szLabel,pSolidSIDVacuumSensor,m_MapMaterials[std::string("std::Vacuum")]);
59  GeoFullPhysVol* pPhysSIDVacuumSensor=new GeoFullPhysVol(pLogSIDVacuumSensor);
60  sprintf(szLabel,"%s_SIDVacuumSensor[%i]",pszStationName,nSpecVacSensorID);
61  pPhysMotherVol->add(new GeoNameTag(szLabel));
62  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(m_pGeometry->getSIDTransform(ESTT_VACUUMSENSOR,pszStationName,nSpecVacSensorID))));
63  pPhysMotherVol->add(pPhysSIDVacuumSensor);
64 
65 
66  for(int i=0;i<m_pGeometry->getSIDPlatesCnt(eStation);i++)
67  {
68  // create SID plate
69  sprintf(szLabel,"%s_LogSIDPlate[%i]",pszStationName,i);
70  pLogElement=new GeoLogVol(szLabel,pSolidSIDPlate,m_MapMaterials[std::string("CE7")]);
71  pPhysElement=new GeoFullPhysVol(pLogElement);
72  sprintf(szLabel,"%s_SIDPlate[%i]",pszStationName,i);
73  pPhysMotherVol->add(new GeoNameTag(szLabel));
74  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_PLATE,pszStationName,i))));
75  pPhysMotherVol->add(pPhysElement);
76 
77  // create SID chip
78  GeoShape* pSolidFEI4Chip=new GeoBox(0.5*sidcfg.vecChipXLength[i],0.5*sidcfg.vecChipYLength[i],0.5*AFP_CONSTANTS::SiT_Chip_thickness);
79  sprintf(szLabel,"%s_LogSIDChip[%i]",pszStationName,i);
80  pLogElement=new GeoLogVol(szLabel,pSolidFEI4Chip,m_MapMaterials[std::string("CE7")]);
81  pPhysElement=new GeoFullPhysVol(pLogElement);
82  sprintf(szLabel,"%s_SIDChip[%i]",pszStationName,i);
83  pPhysMotherVol->add(new GeoNameTag(szLabel));
84  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_FEI4CHIP,pszStationName,i))));
85  pPhysMotherVol->add(pPhysElement);
86 
87  // create SID sensor (pixel area)
88  sprintf(szLabel,"%s_LogSIDSensor[%i]",pszStationName,i);
89  pLogElement=new GeoLogVol(szLabel,pSolidSIDSensor,m_MapMaterials[std::string("Silicon")]);
90  pPhysElement=new GeoFullPhysVol(pLogElement);
91  sprintf(szLabel,"%s_SIDSensor[%i]",pszStationName,i);
92  pPhysMotherVol->add(new GeoNameTag(szLabel));
93  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransInMotherVolume*m_pGeometry->getSIDTransform(ESTT_SENSOR,pszStationName,i))));
94  pPhysMotherVol->add(pPhysElement);
95 
96  if(m_CfgParams.sidcfg[eStation].bAddVacuumSensors)
97  {
98  // create logic SID Vacuum Layer
99  sprintf(szLabel,"%s_LogSIDVacuumSensor[%i]",pszStationName,i);
100  GeoLogVol* pLogSIDVacuumSensor=new GeoLogVol(szLabel,pSolidSIDVacuumSensor,m_MapMaterials[std::string("std::Vacuum")]);
101  GeoFullPhysVol* pPhysSIDVacuumSensor=new GeoFullPhysVol(pLogSIDVacuumSensor);
102 
103  sprintf(szLabel,"%s_SIDVacuumSensor[%i]",pszStationName,i);
104  pPhysMotherVol->add(new GeoNameTag(szLabel));
105  pPhysMotherVol->add(new GeoTransform(Amg::CLHEPTransformToEigen(m_pGeometry->getSIDTransform(ESTT_VACUUMSENSOR,pszStationName,i))));
106  pPhysMotherVol->add(pPhysSIDVacuumSensor);
107  }
108  }
109 }

◆ addTimingDetector()

StatusCode AFP_GeoModelFactory::addTimingDetector ( const char *  pszStationName,
GeoOpticalPhysVol *  pPhysMotherVol,
HepGeom::Transform3D &  TransInMotherVolume,
GeoBorderSurfaceContainer *  bsContainer 
)
private

Definition at line 62 of file AFP_GeoModelTD.cxx.

63 {
64  int i,j,nPixelID;
65  double fXShift,fYShift,fZShift;
66 
67  eAFPStation eStation=m_pGeometry->parseStationName(pszStationName);
68 
69  AFP_TDCONFIGURATION TofCfg=m_CfgParams.tdcfg[eStation];
70  AFPTOF_LBARDIMENSIONS BarDims11=TofCfg.mapBarDims[11];
71  fXShift=-73.5*CLHEP::mm; //FIXME TODO
72  fYShift=(BarDims11.fRadLength+TofCfg.mapTrainInfo[BarDims11.nTrainID].fPerpShiftInPixel-0.5*(BarDims11.fLGuideWidth-TofCfg.mapTrainInfo[BarDims11.nTrainID].fTaperOffset)-0.5*BarDims11.fLBarThickness/std::tan(TofCfg.fAlpha))*std::sin(TofCfg.fAlpha);
73  fZShift=fabs(fYShift)/std::tan(TofCfg.fAlpha)+0.5*BarDims11.fLBarThickness/std::sin(TofCfg.fAlpha);
74 
75  HepGeom::Transform3D TofTransform=TransInMotherVolume*HepGeom::Translate3D(fXShift,fYShift,fZShift)*HepGeom::RotateX3D((90.0*CLHEP::deg-TofCfg.fAlpha))*HepGeom::RotateZ3D(-90.0*CLHEP::deg);
76 
77  for(i=0;i<m_CfgParams.tdcfg[eStation].nX1PixCnt;i++)
78  {
79  for(j=0;j<m_CfgParams.tdcfg[eStation].nX2PixCnt;j++)
80  {
81  nPixelID=10*(i+1)+(j+1);
82  addSepRadLBar(pszStationName,1,nPixelID,pPhysMotherVol,TofTransform,bsContainer);
83  }
84  }
85 
86  if(m_addSeparationWindow)
87  {
88  addLBarSensorSeparationWindow(pszStationName,1,pPhysMotherVol,TofTransform,bsContainer);
89  }
90  addSensor(pszStationName,1,pPhysMotherVol,TofTransform,bsContainer);
91 
92  return StatusCode::SUCCESS;
93 }

◆ create()

void AFP_GeoModelFactory::create ( GeoPhysVol *  world)
virtual

Definition at line 220 of file AFP_GeoModelFactory.cxx.

221 {
222  char szLabel[32];
223  StatusCode SCode;
224  m_pDetectorManager=new AFP_GeoModelManager();
225  HepGeom::Transform3D TransEnvInWorld;
226  HepGeom::Transform3D PosElementInEnv;
227 
228  //define materials
229  defineMaterials();
230 
231  // Initialization of Surface Container for TD Surface(s)
232  GeoBorderSurfaceContainer* pBSContainer = new GeoBorderSurfaceContainer();
233  pBSContainer->reserve(AFP_CONSTANTS::ToF_TrainsCnt*AFP_CONSTANTS::ToF_ColumnsCnt);
234 
235  //AFP00 (SIDE A (+z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
236 
237  //Optical Envelope
238  TransEnvInWorld=m_pGeometry->getStationTransform("AFP00");
239  const GeoBox* pBoxLongEnv= new GeoBox(150*mm, 150*CLHEP::mm, 280*CLHEP::mm);
240  const GeoLogVol* pLogLongEnv = new GeoLogVol("AFP00_LogStationEnv", pBoxLongEnv, m_MapMaterials[std::string("OpticalVacuum")]);
241  GeoOpticalPhysVol* pPhysLongEnv = new GeoOpticalPhysVol(pLogLongEnv);
242  sprintf(szLabel,"AFP00_StationEnv");
243  world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
244  world->add(new GeoNameTag(szLabel));
245  world->add(pPhysLongEnv);
246  m_pDetectorManager->addTreeTop(pPhysLongEnv);
247 
248  //Roman Pot
249  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_RPOT);
250  addRomanPot(pPhysLongEnv,"AFP00",PosElementInEnv);
251 
252  //Timing detector
253  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_TOF);
254  SCode=addTimingDetector("AFP00",pPhysLongEnv,PosElementInEnv, pBSContainer);
255 
256  //Silicon detector
257  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP00",ESE_SID);
258  addSiDetector(pPhysLongEnv,"AFP00",PosElementInEnv);
259 
260  //AFP01 (SIDE A (+z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
261 
262  //add envelope -- short beampipe (station A)
263  TransEnvInWorld=m_pGeometry->getStationTransform("AFP01");
264  const GeoBox* pBoxShortEnv= new GeoBox(150*CLHEP::mm, 150*CLHEP::mm, 280*CLHEP::mm);
265  const GeoLogVol* pLogShortEnv = new GeoLogVol("AFP01_LogStationEnv", pBoxShortEnv, m_MapMaterials[std::string("std::Vacuum")]);
266  GeoPhysVol* pPhysShortEnv = new GeoPhysVol(pLogShortEnv);
267  sprintf(szLabel,"AFP01_StationEnv");
268  world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
269  world->add(new GeoNameTag(szLabel));
270  world->add(pPhysShortEnv);
271  m_pDetectorManager->addTreeTop(pPhysShortEnv);
272 
273  //Roman Pot
274  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP01",ESE_RPOT);
275  addRomanPot(pPhysShortEnv,"AFP01",PosElementInEnv);
276 
277  //Silicon detector
278  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP01",ESE_SID);
279  addSiDetector(pPhysShortEnv,"AFP01",PosElementInEnv);
280 
281  //AFP02 (SIDE C (-z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
282 
283  //add envelope -- short beampipe (station C)
284  TransEnvInWorld=m_pGeometry->getStationTransform("AFP02");
285  const GeoBox* pBoxShortEnv1= new GeoBox(150*CLHEP::mm, 150*CLHEP::mm, 280*CLHEP::mm);
286  const GeoLogVol* pLogShortEnv1 = new GeoLogVol("AFP02_LogStationEnv", pBoxShortEnv1, m_MapMaterials[std::string("std::Vacuum")]);
287  GeoPhysVol* pPhysShortEnv1 = new GeoPhysVol(pLogShortEnv1);
288  sprintf(szLabel,"AFP02_StationEnv");
289  world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
290  world->add(new GeoNameTag(szLabel));
291  world->add(pPhysShortEnv1);
292  m_pDetectorManager->addTreeTop(pPhysShortEnv1);
293 
294  //Roman Pot
295  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP02",ESE_RPOT);
296  addRomanPot(pPhysShortEnv1,"AFP02",PosElementInEnv);
297 
298  //Silicon detector
299  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP02",ESE_SID);
300  addSiDetector(pPhysShortEnv1,"AFP02",PosElementInEnv);
301 
302  //AFP03 (SIDE C (-z)) ------------------------------------------------------------------------------------------------------------------------------------------------------
303 
304  // Optical Envelope
305  TransEnvInWorld=m_pGeometry->getStationTransform("AFP03");
306  const GeoBox* pBoxLongEnv1= new GeoBox(150*mm, 150*CLHEP::mm, 280*CLHEP::mm);
307  const GeoLogVol* pLogLongEnv1 = new GeoLogVol("AFP03_LogStationEnv", pBoxLongEnv1, m_MapMaterials[std::string("OpticalVacuum")]);
308  GeoOpticalPhysVol* pPhysLongEnv1 = new GeoOpticalPhysVol(pLogLongEnv1);
309  sprintf(szLabel,"AFP03_StationEnv");
310  world->add(new GeoTransform(Amg::CLHEPTransformToEigen(TransEnvInWorld)));
311  world->add(new GeoNameTag(szLabel));
312  world->add(pPhysLongEnv1);
313  m_pDetectorManager->addTreeTop(pPhysLongEnv1);
314 
315  //Roman Pot
316  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_RPOT);
317  addRomanPot( pPhysLongEnv1,"AFP03",PosElementInEnv);
318 
319  //Timing detector
320  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_TOF);
321  SCode=addTimingDetector("AFP03",pPhysLongEnv1,PosElementInEnv, pBSContainer);
322 
323  //Silicon detector
324  PosElementInEnv=m_pGeometry->getStationElementTransform("AFP03",ESE_SID);
325  addSiDetector(pPhysLongEnv1,"AFP03",PosElementInEnv);
326 
327 
328 
329  //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
330 
331  // Register the Surface Container with the Detector Store
332  SCode=m_pDetectorStore->record(pBSContainer, "AFP_GeoModel");
333  if (SCode.isFailure()){
334 
335  }
336 }

◆ createSolidSIDPlate()

GeoShape * AFP_GeoModelFactory::createSolidSIDPlate ( )
private

Definition at line 112 of file AFP_GeoModelSID.cxx.

113 {
114  MsgStream LogStream(Athena::getMessageSvc(), "AFP_GeoModelFactory::CreateSolidSIDPlate");
115 
116  double fdelta=0.01*CLHEP::mm;//0.01*CLHEP::mm;
117 
118  GeoBox* pMainPlate=new GeoBox(0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness);
119 
120  //cut side edges
121  double fd=std::sqrt(AFP_CONSTANTS::SiT_Plate_CutEdge_length_x*AFP_CONSTANTS::SiT_Plate_CutEdge_length_x+AFP_CONSTANTS::SiT_Plate_CutEdge_length_y*AFP_CONSTANTS::SiT_Plate_CutEdge_length_y);
122  double falpha=std::atan(AFP_CONSTANTS::SiT_Plate_CutEdge_length_y/AFP_CONSTANTS::SiT_Plate_CutEdge_length_x);
123  double fgamma=45.0*CLHEP::deg-falpha; double fbeta=90.0*CLHEP::deg-falpha;
124 
125  //--lower cut
126  HepGeom::Vector3D<double> vecL=(fd/std::sqrt(2.0))*(HepGeom::RotateZ3D(-fgamma)*HepGeom::Vector3D<double>(1.0,0.0,0.0));
127  HepGeom::Vector3D<double> vecB=AFP_CONSTANTS::SiT_Plate_CutEdge_length_x*HepGeom::Vector3D<double>(1.0,0.0,0.0);
128  HepGeom::Vector3D<double> vecX=vecL-vecB;
129  GeoBox* pPlateCut=new GeoBox(0.5*fd, 0.5*fd,0.5*(AFP_CONSTANTS::SiT_Plate_CutEdge_thickness+fdelta));
130  HepGeom::Transform3D TransCut=HepGeom::Translate3D(vecX.x()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,vecX.y()-0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.0)*HepGeom::RotateZ3D(-fbeta);
131  GeoShapeShift* pShiftCut=new GeoShapeShift(pPlateCut, Amg::CLHEPTransformToEigen(TransCut));
132  GeoShapeSubtraction* pShape1=new GeoShapeSubtraction(pMainPlate, pShiftCut);
133 
134  //--upper cut
135  vecL=(fd/std::sqrt(2.0))*(HepGeom::RotateZ3D(+fgamma)*HepGeom::Vector3D<double>(1.0,0.0,0.0));
136  vecX=vecL-vecB;
137  pPlateCut=new GeoBox(0.5*fd, 0.5*fd,0.5*(AFP_CONSTANTS::SiT_Plate_CutEdge_thickness+fdelta));
138  TransCut=HepGeom::Translate3D(vecX.x()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_x,vecX.y()+0.5*AFP_CONSTANTS::SiT_Plate_Main_length_y,0.0)*HepGeom::RotateZ3D(+fbeta);
139  pShiftCut=new GeoShapeShift(pPlateCut,Amg::CLHEPTransformToEigen(TransCut));
140  GeoShapeSubtraction* pShape2=new GeoShapeSubtraction(pShape1, pShiftCut);
141 
142  //cut sensitive area
143  pPlateCut=new GeoBox(0.5*(AFP_CONSTANTS::SiT_Plate_Window_length_x+fdelta),0.5*AFP_CONSTANTS::SiT_Plate_Window_length_y,0.5*AFP_CONSTANTS::SiT_Plate_Window_thickness);
144  TransCut=HepGeom::Translate3D(AFP_CONSTANTS::SiT_Plate_Window_x+fdelta,AFP_CONSTANTS::SiT_Plate_Window_y,-(0.5*AFP_CONSTANTS::SiT_Plate_Main_thickness-0.5*AFP_CONSTANTS::SiT_Plate_Window_thickness));
145  pShiftCut=new GeoShapeShift(pPlateCut,Amg::CLHEPTransformToEigen(TransCut));
146  GeoShapeSubtraction* pShape3=new GeoShapeSubtraction(pShape2, pShiftCut);
147 
148  return pShape3;
149 }

◆ defineMaterials()

void AFP_GeoModelFactory::defineMaterials ( )
private

Definition at line 59 of file AFP_GeoModelFactory.cxx.

60 {
61  int i;
62  const double fWl2E=1239.85; //nm<->eV
63  std::string matName;
64  GeoMaterialPropertiesTable *pMPT=nullptr;
65 
66  StoredMaterialManager * materialManager = nullptr;
67  if (StatusCode::SUCCESS != m_pDetectorStore->retrieve(materialManager, std::string("MATERIALS")))
68  {
69  return;
70  }
71 
72  double aH,aC,aN,aSi,aP,aS,aCr,aMn,aFe,aNi,aMo,aAl,aO,Atot;
73  const GeoElement* H = materialManager->getElement("Hydrogen");
74  const GeoElement* C = materialManager->getElement("Carbon");
75  const GeoElement* N = materialManager->getElement("Nitrogen");
76  const GeoElement* Si = materialManager->getElement("Silicon");
77  const GeoElement* P = materialManager->getElement("Phosphorus");
78  const GeoElement* S = materialManager->getElement("Sulfur");
79  const GeoElement* Cr = materialManager->getElement("Chromium");
80  const GeoElement* Mn = materialManager->getElement("Manganese");
81  const GeoElement* Fe = materialManager->getElement("Iron");
82  const GeoElement* Ni = materialManager->getElement("Nickel");
83  const GeoElement* Mo = materialManager->getElement("Molybdenum");
84  const GeoElement* Al = materialManager->getElement("Aluminium");
85  const GeoElement* O = materialManager->getElement("Oxygen");
86  const GeoElement* Be = materialManager->getElement("Beryllium");
87 
88  // vacuum
89  matName = "std::Vacuum";
90  const GeoMaterial *vacuum = materialManager->getMaterial(matName);
91  m_MapMaterials.emplace(matName,vacuum);
92 
93  // optical vacuum
94  matName = "OpticalVacuum";
95  GeoExtendedMaterial* pMatOptVacuum=new GeoExtendedMaterial(matName, (1E-24)*CLHEP::g/CLHEP::cm3);
96  pMatOptVacuum->add(const_cast<GeoElement*> (H), 1);
97  double PhotonEnergyOptVac[2] = {0.44*CLHEP::eV, 6.3*CLHEP::eV};
98  double RefractiveIndexOptVac[2] = {1.0, 1.0};
99  double AbsorptionOptVac[2] ={1E-5*CLHEP::m, 1E-5*CLHEP::m};
100 
101  pMPT= new GeoMaterialPropertiesTable();
102  pMPT->AddProperty("RINDEX", PhotonEnergyOptVac, RefractiveIndexOptVac , 2);
103  pMPT->AddProperty("ABSLENGTH", PhotonEnergyOptVac, AbsorptionOptVac, 2);
104  pMatOptVacuum->SetMaterialPropertiesTable(pMPT);
105  pMatOptVacuum->lock();
106  m_MapMaterials.emplace(matName,pMatOptVacuum);
107 
108  // Steel Grade 316L (Roman Pot)
109  matName="Steel_AFP";
110  GeoMaterial *steel=new GeoMaterial(matName, 8*g/cm3);
111 
112  aFe=62.045*Fe->getA()/(CLHEP::g/CLHEP::mole);
113  aC =0.03*C ->getA()/(CLHEP::g/CLHEP::mole);
114  aMn=2.0*Mn ->getA()/(CLHEP::g/CLHEP::mole);
115  aSi=0.75*Si->getA()/(CLHEP::g/CLHEP::mole);
116  aP =0.045*P->getA()/(CLHEP::g/CLHEP::mole);
117  aS =0.03*S ->getA()/(CLHEP::g/CLHEP::mole);
118  aCr=18.0*Cr->getA()/(CLHEP::g/CLHEP::mole);
119  aMo=3.0*Mo ->getA()/(CLHEP::g/CLHEP::mole);
120  aNi=14.0*Ni->getA()/(CLHEP::g/CLHEP::mole);
121  aN =0.10*N ->getA()/(CLHEP::g/CLHEP::mole);
122  Atot=aFe+aC+aMn+aSi+aP+aS+aCr+aMo+aNi+aN;
123 
124  steel->add(const_cast<GeoElement*> (Fe),aFe/Atot);
125  steel->add(const_cast<GeoElement*> (C), aC/Atot);
126  steel->add(const_cast<GeoElement*> (Mn),aMn/Atot);
127  steel->add(const_cast<GeoElement*> (Si),aSi/Atot);
128  steel->add(const_cast<GeoElement*> (P), aP/Atot);
129  steel->add(const_cast<GeoElement*> (S), aS/Atot);
130  steel->add(const_cast<GeoElement*> (Cr),aCr/Atot);
131  steel->add(const_cast<GeoElement*> (Mo),aMo/Atot);
132  steel->add(const_cast<GeoElement*> (Ni),aNi/Atot);
133  steel->add(const_cast<GeoElement*> (N), aN/Atot);
134  steel->lock();
135  m_MapMaterials.emplace(matName,steel);
136 
137  // CE7 70% Si, 30% Al
138  matName="CE7";
139  GeoMaterial *pMatCE7=new GeoMaterial(matName, 2.4*g/cm3);
140  aSi=0.70*Si->getA()/(g/mole);
141  aAl=0.30*Al->getA()/(g/mole);
142  Atot=aSi+aAl;
143  pMatCE7->add(const_cast<GeoElement*> (Si),aSi/Atot);
144  pMatCE7->add(const_cast<GeoElement*> (Al),aAl/Atot);
145  pMatCE7->lock();
146  m_MapMaterials.emplace(matName,pMatCE7);
147 
148  // Quartz 70% SiO2 for TD Quartic (with refractive index and absorption length)
149  matName="Quartz";
150  GeoExtendedMaterial *pMatQuartz=new GeoExtendedMaterial(matName, 2.6*g/cm3, stateSolid, CLHEP::STP_Temperature);
151  aSi=1.0*Si->getA()/(g/mole);
152  aO=2.0*O->getA()/(g/mole);
153  Atot=aSi+aO;
154  pMatQuartz->add(const_cast<GeoElement*> (Si),aSi/Atot);
155  pMatQuartz->add(const_cast<GeoElement*> (O),aO/Atot);
156 
157  // Defining the refractive index of quartz
158  const int nEntriesCnt1=12; // (M.G.Albrow, JINST 2012) + extrapolation to 200.0 nm
159  double arrEnergy1[nEntriesCnt1] = { 750.0*nm, 700.0*nm, 650.0*nm, 600.0*nm, 550.0*nm, 500.0*nm, 450.0*nm, 400.0*nm, 350.0*nm, 300.0*nm, 250.0*nm, 200.0*nm };
160  double arrQuartzRefIndex[nEntriesCnt1] = { 1.450, 1.455, 1.456, 1.458, 1.460, 1.462, 1.465, 1.470, 1.475, 1.488, 1.510, 1.541 };
161  double arrQuartzAbsLength[nEntriesCnt1] = { 130.0*cm, 130.0*cm, 130.0*cm, 130.0*cm, 128.0*cm, 125.0*cm, 122.0*cm, 120.0*cm, 111.0*cm, 104.0*cm, 95.0*cm, 83.3*cm };
162  for(i=0;i<nEntriesCnt1;i++) arrEnergy1[i]=(fWl2E/(arrEnergy1[i]/nm))*eV;
163 
164  pMPT= new GeoMaterialPropertiesTable();
165  pMPT->AddProperty("RINDEX", arrEnergy1, arrQuartzRefIndex, nEntriesCnt1);
166  pMPT->AddProperty("ABSLENGTH", arrEnergy1, arrQuartzAbsLength, nEntriesCnt1);
167  pMatQuartz->SetMaterialPropertiesTable(pMPT);
168  pMatQuartz->lock();
169  m_MapMaterials.emplace(matName,pMatQuartz);
170 
171  // Silicon for TD SiPMT (with refractive index)
172  matName="SiliconPMT";
173  GeoExtendedMaterial *pMatSiliconPMT=new GeoExtendedMaterial(matName, 2.3290*g/cm3, stateSolid, CLHEP::STP_Temperature);
174  aSi=1.0*Si->getA()/(g/mole);
175  pMatSiliconPMT->add(const_cast<GeoElement*> (Si),1.0);
176 
177  const int nEntriesCnt2=2;
178  double arrEnergy2[nEntriesCnt2] = { 2800.0*nm, 190.0*nm };
179  double arrSiliconRefIndex[nEntriesCnt2] = { 4.0, 4.0 };
180  double arrSiliconAbsLength[nEntriesCnt2] = { 0.00001*m, 0.00001*m };
181  for(i=0;i<nEntriesCnt2;i++) arrEnergy2[i]=(fWl2E/(arrEnergy2[i]/nm))*eV;
182 
183  pMPT = new GeoMaterialPropertiesTable();
184  pMPT->AddProperty("RINDEX", arrEnergy2, arrSiliconRefIndex, nEntriesCnt2);
185  pMPT->AddProperty("ABSLENGTH", arrEnergy2, arrSiliconAbsLength, nEntriesCnt2);
186  pMatSiliconPMT->SetMaterialPropertiesTable(pMPT);
187  pMatSiliconPMT->lock();
188  m_MapMaterials.emplace(matName,pMatSiliconPMT);
189 
190 
191  // Silicon
192  matName="Silicon";
193  GeoMaterial *pMatSilicon=new GeoMaterial(matName, 2.3290*g/cm3);
194  aSi=1.0*Si->getA()/(g/mole);
195  pMatSilicon->add(const_cast<GeoElement*> (Si),1.0);
196  pMatSilicon->lock();
197  m_MapMaterials.emplace(matName,pMatSilicon);
198 
199  // Water
200  matName="Water";
201  GeoMaterial *pMatWater=new GeoMaterial(matName, 1.0*g/cm3);
202  aH=0.11*Si->getA()/(g/mole);
203  aO=0.89*Al->getA()/(g/mole);
204  Atot=aH+aO;
205  pMatWater->add(const_cast<GeoElement*> (H),aH/Atot);
206  pMatWater->add(const_cast<GeoElement*> (O),aO/Atot);
207  pMatWater->lock();
208  m_MapMaterials.emplace(matName,pMatWater);
209 
210  // Beryllium
211  matName="Beryllium_AFP";
212  GeoMaterial* pMaterialBe=new GeoMaterial(matName, 1.848*CLHEP::g/CLHEP::cm3);
213 
214  pMaterialBe->add(const_cast<GeoElement*> (Be), 1);
215  pMaterialBe->lock();
216  m_MapMaterials.emplace(matName,pMaterialBe);
217 }

◆ getBarShift()

HepGeom::Vector3D<double> AFP_GeoModelFactory::getBarShift ( AFPTOF_LBARDIMENSIONS &  LQBarDims,
eLBarType  eSpecType = ELBT_UNDEFINED 
)
private

◆ getDetectorManager()

const AFP_GeoModelManager * AFP_GeoModelFactory::getDetectorManager ( ) const
virtual

Definition at line 338 of file AFP_GeoModelFactory.cxx.

339 {
340  return m_pDetectorManager;
341 }

◆ getLQBarDimensions()

void AFP_GeoModelFactory::getLQBarDimensions ( const int  nRowID,
const int  nColID,
AFPTOF_LBARDIMENSIONS *  pLQBarDims 
)
private

◆ initializeTDParameters()

void AFP_GeoModelFactory::initializeTDParameters ( )
private

Definition at line 49 of file AFP_GeoModelTD.cxx.

50 {
51  // Surface definition (preliminary)
52  m_pOpticalSurface = new GeoOpticalSurface("TDQuarticOpticalSurface", GeoOpticalSurface::unified, GeoOpticalSurface::polished, GeoOpticalSurface::dielectric_dielectric, GeoOpticalSurface::polished);
53 
54  m_pReflectionOptSurface=new GeoOpticalSurface("AirLightGuideSurface", GeoOpticalSurface::unified, GeoOpticalSurface::polished, GeoOpticalSurface::dielectric_metal, GeoOpticalSurface::polished);
55  GeoMaterialPropertiesTable* pMPT=new GeoMaterialPropertiesTable();
56  double pfEnergy1[2]={ 1.62*CLHEP::eV, 6.20*CLHEP::eV };
57  double pfReflectivity1[2]={ 0.9, 0.9};
58  pMPT->AddProperty("REFLECTIVITY",pfEnergy1,pfReflectivity1,2);
59  m_pReflectionOptSurface->SetMaterialPropertiesTable(pMPT);
60 }

◆ operator=()

const AFP_GeoModelFactory& AFP_GeoModelFactory::operator= ( const AFP_GeoModelFactory &  right)
private

◆ updatePositions()

void AFP_GeoModelFactory::updatePositions ( AFP_BPMCOOLPARAMS *  pBpmParams)

Definition at line 344 of file AFP_GeoModelFactory.cxx.

345 {
346 
347 }

Member Data Documentation

◆ m_addSeparationWindow

const bool AFP_GeoModelFactory::m_addSeparationWindow
private

Definition at line 61 of file AFP_GeoModelFactory.h.

◆ m_CfgParams

AFP_CONFIGURATION AFP_GeoModelFactory::m_CfgParams
private

Definition at line 59 of file AFP_GeoModelFactory.h.

◆ m_MapMaterials

std::map<std::string, GeoRef<const GeoMaterial> > AFP_GeoModelFactory::m_MapMaterials
private

Definition at line 44 of file AFP_GeoModelFactory.h.

◆ m_MapShape

std::map<std::string,const GeoShape*> AFP_GeoModelFactory::m_MapShape
private

Definition at line 58 of file AFP_GeoModelFactory.h.

◆ m_pDetectorManager

AFP_GeoModelManager* AFP_GeoModelFactory::m_pDetectorManager
private

Definition at line 53 of file AFP_GeoModelFactory.h.

◆ m_pDetectorStore

StoreGateSvc* AFP_GeoModelFactory::m_pDetectorStore
private

Definition at line 54 of file AFP_GeoModelFactory.h.

◆ m_pGeometry

AFP_Geometry* AFP_GeoModelFactory::m_pGeometry
private

Definition at line 60 of file AFP_GeoModelFactory.h.

◆ m_pOpticalSurface

GeoOpticalSurface* AFP_GeoModelFactory::m_pOpticalSurface = nullptr
private

Definition at line 69 of file AFP_GeoModelFactory.h.

◆ m_pReflectionOptSurface

GeoOpticalSurface* AFP_GeoModelFactory::m_pReflectionOptSurface = nullptr
private

Definition at line 70 of file AFP_GeoModelFactory.h.

The documentation for this class was generated from the following files:
AFP_SIDCONFIGURATION
Definition: AFP_ConfigParams.h:105
GeoOpticalPhysVol
Ensure that the extensions for the Vector3D are properly loaded.
Definition: GeoOpticalPhysVol.h:14
RPOT_MAINTUBUS_LENGTH
#define RPOT_MAINTUBUS_LENGTH
Definition: AFP_GeoModelRP.cxx:42
GeoOpticalSurface::dielectric_metal
@ dielectric_metal
Definition: GeoOpticalSurface.h:24
AFP_TDCONFIGURATION::nX2PixCnt
int nX2PixCnt
Definition: AFP_ConfigParams.h:85
AFP_SIDCONFIGURATION::vecChipYLength
std::vector< double > vecChipYLength
Definition: AFP_ConfigParams.h:119
GeoOpticalSurface::dielectric_dielectric
@ dielectric_dielectric
Definition: GeoOpticalSurface.h:25
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
GeoOpticalSurface::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(GeoMaterialPropertiesTable *mpt)
Definition: GeoOpticalSurface.h:62
RPOT_MAINTUBUS_BPTHICKNESS
#define RPOT_MAINTUBUS_BPTHICKNESS
Definition: AFP_GeoModelRP.cxx:45
python.PhysicalConstants.STP_Temperature
float STP_Temperature
Definition: PhysicalConstants.py:119
RPOT_MAINTUBUS_THICKNESS
#define RPOT_MAINTUBUS_THICKNESS
Definition: AFP_GeoModelRP.cxx:44
GeoMaterialPropertiesTable::AddProperty
void AddProperty(const char *key, double *PhotonMomenta, double *PropertyValues, int NumEntries)
Definition: GeoMaterialPropertiesTable.cxx:31
AFP_CONFIGURATION::sidcfg
std::map< eAFPStation, AFP_SIDCONFIGURATION > sidcfg
Definition: AFP_ConfigParams.h:136
AFP_Geometry::getSIDPlatesCnt
int getSIDPlatesCnt(const eAFPStation eStation) const
Definition: AFP_Geometry.h:40
RPOT_FLOOR_WNDTHICKNESS
#define RPOT_FLOOR_WNDTHICKNESS
Definition: AFP_GeoModelRP.cxx:54
AFP_GeoModelFactory::addTimingDetector
StatusCode addTimingDetector(const char *pszStationName, GeoOpticalPhysVol *pPhysMotherVol, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
Definition: AFP_GeoModelTD.cxx:62
DMTest::P
P_v1 P
Definition: P.h:23
AFP_GeoModelFactory::addRomanPot
void addRomanPot(GeoPhysVol *pPhysMotherVol, const char *pszStationName, HepGeom::Transform3D &TransInMotherVolume)
Definition: AFP_GeoModelRP.cxx:60
RPOT_FLANGE_OUTERRADIUS
#define RPOT_FLANGE_OUTERRADIUS
Definition: AFP_GeoModelRP.cxx:58
AFP_TDCONFIGURATION
Definition: AFP_ConfigParams.h:81
DMTest::C
C_v1 C
Definition: C.h:26
AFP_CONSTANTS::ToF_SeparationWindowThickness
static constexpr double ToF_SeparationWindowThickness
Definition: AFP_constants.h:79
AFP_Geometry::getCfgParams
void getCfgParams(AFP_CONFIGURATION *pCfgParams) const
Definition: AFP_Geometry.h:34
StoredMaterialManager::getElement
virtual const GeoElement * getElement(const std::string &name)=0
cm3
#define cm3
deg
#define deg
Definition: SbPolyhedron.cxx:17
ESE_RPOT
@ ESE_RPOT
Definition: AFP_ConfigParams.h:16
stateSolid
@ stateSolid
Definition: GeoExtendedMaterial.h:25
AFP_CONSTANTS::ToF_SensorThickness
static constexpr double ToF_SensorThickness
Definition: AFP_constants.h:84
ESTT_SENSOR
@ ESTT_SENSOR
Definition: AFP_ConfigParams.h:17
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
GeoExtendedMaterial::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(GeoMaterialPropertiesTable *MPT)
Definition: GeoExtendedMaterial.h:73
AFPTOF_LBARDIMENSIONS::fLBarThickness
double fLBarThickness
Definition: AFP_ConfigParams.h:70
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
AFP_CONSTANTS::Stat_GlobalVacuumSensorThickness
static constexpr double Stat_GlobalVacuumSensorThickness
Definition: AFP_constants.h:15
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
AFP_GeoModelFactory::addSepRadLBar
void addSepRadLBar(const char *pszStationName, const int nQuarticID, const int nBarID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
Definition: AFP_GeoModelTD.cxx:95
AFP_GeoModelFactory::createSolidSIDPlate
GeoShape * createSolidSIDPlate()
Definition: AFP_GeoModelSID.cxx:112
AFP_GeoModelFactory::m_CfgParams
AFP_CONFIGURATION m_CfgParams
Definition: AFP_GeoModelFactory.h:59
ESTT_VACUUMSENSOR
@ ESTT_VACUUMSENSOR
Definition: AFP_ConfigParams.h:17
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
AFP_CONSTANTS::ToF_Sensor2BarDist
static constexpr double ToF_Sensor2BarDist
Definition: AFP_constants.h:71
pi
#define pi
Definition: TileMuonFitter.cxx:65
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AFP_Geometry::getStationTransform
HepGeom::Transform3D getStationTransform(const char *pszStationName) const
Definition: AFP_Geometry.cxx:55
AFP_CONSTANTS::ToF_TrainsCnt
static constexpr double ToF_TrainsCnt
Definition: AFP_constants.h:81
AFP_CONSTANTS::SiT_Plate_CutEdge_thickness
static constexpr double SiT_Plate_CutEdge_thickness
Definition: AFP_constants.h:38
AFP_GeoModelFactory::m_pDetectorManager
AFP_GeoModelManager * m_pDetectorManager
Definition: AFP_GeoModelFactory.h:53
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
AFP_GeoModelFactory::addLBarSensorSeparationWindow
void addLBarSensorSeparationWindow(const char *pszStationName, const int nQuarticID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
Definition: AFP_GeoModelTD.cxx:214
AFP_TDCONFIGURATION::bEmulateImmersion
bool bEmulateImmersion
Definition: AFP_ConfigParams.h:89
lwtDev::Component::O
@ O
AFP_GeoModelFactory::m_pGeometry
AFP_Geometry * m_pGeometry
Definition: AFP_GeoModelFactory.h:60
AFP_CONSTANTS::SiT_Plate_Window_length_y
static constexpr double SiT_Plate_Window_length_y
Definition: AFP_constants.h:30
H
#define H(x, y, z)
Definition: MD5.cxx:114
RPOT_FLOOR_WNDWIDTH
#define RPOT_FLOOR_WNDWIDTH
Definition: AFP_GeoModelRP.cxx:53
AFP_GeoModelFactory::m_pOpticalSurface
GeoOpticalSurface * m_pOpticalSurface
Definition: AFP_GeoModelFactory.h:69
AFP_CONSTANTS::SiT_Plate_CutEdge_length_y
static constexpr double SiT_Plate_CutEdge_length_y
Definition: AFP_constants.h:37
AFP_Geometry::getSIDTransform
HepGeom::Transform3D getSIDTransform(const eSIDTransformType eType, const char *pszStationName, const int nPlateID) const
Definition: AFP_Geometry.cxx:136
AFP_TDCONFIGURATION::bApplyBottomCut
bool bApplyBottomCut
Definition: AFP_ConfigParams.h:88
AFP_CONSTANTS::Stat_GlobalVacuumSensorID
static constexpr int Stat_GlobalVacuumSensorID
Definition: AFP_constants.h:14
AFP_GeoModelManager::addTreeTop
void addTreeTop(const PVLink &)
Definition: AFP_GeoModelManager.cxx:27
lumiFormat.i
int i
Definition: lumiFormat.py:85
GeoBorderSurface
Definition: GeoBorderSurface.h:18
ESE_TOF
@ ESE_TOF
Definition: AFP_ConfigParams.h:16
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
AFP_CONSTANTS::SiT_Plate_CutEdge_length_x
static constexpr double SiT_Plate_CutEdge_length_x
Definition: AFP_constants.h:36
AFP_CONFIGURATION::tdcfg
std::map< eAFPStation, AFP_TDCONFIGURATION > tdcfg
Definition: AFP_ConfigParams.h:137
AFP_CONSTANTS::SiT_Chip_thickness
static constexpr double SiT_Chip_thickness
Definition: AFP_constants.h:50
AFP_GeoModelFactory::addSensor
void addSensor(const char *pszStationName, const int nQuarticID, GeoOpticalPhysVol *pPhysMotherVolume, HepGeom::Transform3D &TransInMotherVolume, GeoBorderSurfaceContainer *bsContainer)
Definition: AFP_GeoModelTD.cxx:250
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
GeoOpticalSurface::unified
@ unified
Definition: GeoOpticalSurface.h:43
AFP_Geometry::getStationElementTransform
HepGeom::Transform3D getStationElementTransform(const char *pszStationName, eStationElement eElement, const int nPlateID=-1) const
Definition: AFP_Geometry.cxx:81
SLIMCUT
#define SLIMCUT
Definition: AFP_GeoModelFactory.h:15
AFP_CONSTANTS::SiT_Plate_Main_length_x
static constexpr double SiT_Plate_Main_length_x
Definition: AFP_constants.h:25
AFP_CONSTANTS::SiT_Plate_Window_thickness
static constexpr double SiT_Plate_Window_thickness
Definition: AFP_constants.h:31
AFPTOF_LBARDIMENSIONS::fLGuideLength
double fLGuideLength
Definition: AFP_ConfigParams.h:74
GeoOpticalSurface
Ensure that the extensions for the Vector3D are properly loaded.
Definition: GeoOpticalSurface.h:19
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AFP_Geometry::parseStationName
eAFPStation parseStationName(const char *pszStationName) const
Definition: AFP_Geometry.cxx:214
AFP_CONSTANTS::ToF_SeparationWindowDiameter
static constexpr double ToF_SeparationWindowDiameter
Definition: AFP_constants.h:78
AFP_Geometry::getPixelLocalPosition
void getPixelLocalPosition(const eAFPStation eStation, const int nPixelID, double *pfX1Pos, double *pfX2Pos) const
Definition: AFP_Geometry.cxx:264
AFP_TDCONFIGURATION::mapTrainInfo
std::map< int, AFPTOF_TRAININFO > mapTrainInfo
Definition: AFP_ConfigParams.h:95
eAFPStation
eAFPStation
Definition: AFP_ConfigParams.h:18
ReadFromCoolCompare.fd
fd
Definition: ReadFromCoolCompare.py:196
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
AFP_CONSTANTS::SiT_Plate_Window_y
static constexpr double SiT_Plate_Window_y
Definition: AFP_constants.h:34
AFP_GeoModelFactory::initializeTDParameters
void initializeTDParameters()
Definition: AFP_GeoModelTD.cxx:49
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
python.SystemOfUnits.eV
int eV
Definition: SystemOfUnits.py:155
AFP_GeoModelManager
Definition: AFP_GeoModelManager.h:11
AFP_SIDCONFIGURATION::vecChipXLength
std::vector< double > vecChipXLength
Definition: AFP_ConfigParams.h:118
RPOT_MAINTUBUS_FLOORPARTLENGTH
#define RPOT_MAINTUBUS_FLOORPARTLENGTH
Definition: AFP_GeoModelRP.cxx:49
AFP_GeoModelFactory::m_pReflectionOptSurface
GeoOpticalSurface * m_pReflectionOptSurface
Definition: AFP_GeoModelFactory.h:70
AFPTOF_LBARDIMENSIONS
Definition: AFP_ConfigParams.h:61
AFP_GeoModelFactory::defineMaterials
void defineMaterials()
Definition: AFP_GeoModelFactory.cxx:59
RPOT_FLOOR_WNDFACET
#define RPOT_FLOOR_WNDFACET
Definition: AFP_GeoModelRP.cxx:55
AFP_GeoModelFactory::m_pDetectorStore
StoreGateSvc * m_pDetectorStore
Definition: AFP_GeoModelFactory.h:54
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
AFP_CONFIGURATION::clear
void clear()
Definition: AFP_ConfigParams.cxx:9
AFP_CONSTANTS::SiT_Plate_Main_length_y
static constexpr double SiT_Plate_Main_length_y
Definition: AFP_constants.h:26
AFP_CONSTANTS::ToF_ColumnsCnt
static constexpr double ToF_ColumnsCnt
Definition: AFP_constants.h:82
AFP_TDCONFIGURATION::nX1PixCnt
int nX1PixCnt
Definition: AFP_ConfigParams.h:84
AFP_GeoModelFactory::m_addSeparationWindow
const bool m_addSeparationWindow
Definition: AFP_GeoModelFactory.h:61
RPOT_FLOOR_THICKNESS
#define RPOT_FLOOR_THICKNESS
Definition: AFP_GeoModelRP.cxx:52
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:110
AFP_TDCONFIGURATION::mapBarDims
std::map< int, AFPTOF_LBARDIMENSIONS > mapBarDims
Definition: AFP_ConfigParams.h:94
AFP_CONSTANTS::SiT_Plate_Window_x
static constexpr double SiT_Plate_Window_x
Definition: AFP_constants.h:33
GeoBorderSurfaceContainer
std::vector< GeoBorderSurface > GeoBorderSurfaceContainer
Definition: GeoBorderSurfaceContainer.h:12
Amg::CLHEPTransformToEigen
Amg::Transform3D CLHEPTransformToEigen(const HepGeom::Transform3D &CLHEPtransf)
Converts a CLHEP-based HepGeom::Transform3D into an Eigen Amg::Transform3D.
Definition: CLHEPtoEigenConverter.h:38
AFPTOF_LBARDIMENSIONS::fRadYDim
double fRadYDim
Definition: AFP_ConfigParams.h:72
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
AFP_CONSTANTS::SiT_Pixel_thickness
static constexpr double SiT_Pixel_thickness
Definition: AFP_constants.h:60
AFP_TDCONFIGURATION::fPixelX1Dim
double fPixelX1Dim
Definition: AFP_ConfigParams.h:86
AFP_CONSTANTS::SiT_Plate_Main_thickness
static constexpr double SiT_Plate_Main_thickness
Definition: AFP_constants.h:27
AFP_CONSTANTS::SiT_Plate_Window_length_x
static constexpr double SiT_Plate_Window_length_x
Definition: AFP_constants.h:29
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
ESTT_PLATE
@ ESTT_PLATE
Definition: AFP_ConfigParams.h:17
mole
#define mole
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
AFP_CONSTANTS::SiT_Pixel_length_toty
static constexpr double SiT_Pixel_length_toty
Definition: AFP_constants.h:62
AFP_TDCONFIGURATION::fPixelX2Dim
double fPixelX2Dim
Definition: AFP_ConfigParams.h:87
ESE_SID
@ ESE_SID
Definition: AFP_ConfigParams.h:16
AFPTOF_LBARDIMENSIONS::nTrainID
int nTrainID
Definition: AFP_ConfigParams.h:69
AFPTOF_LBARDIMENSIONS::fLGuideWidth
double fLGuideWidth
Definition: AFP_ConfigParams.h:73
GeoMaterialPropertiesTable
Definition: GeoMaterialPropertiesTable.h:20
AFPTOF_LBARDIMENSIONS::fRadLength
double fRadLength
Definition: AFP_ConfigParams.h:71
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
RPOT_FLANGE_THICKNESS
#define RPOT_FLANGE_THICKNESS
Definition: AFP_GeoModelRP.cxx:57
AFP_CONSTANTS::SiT_Pixel_length_totx
static constexpr double SiT_Pixel_length_totx
Definition: AFP_constants.h:61
RPOT_MAINTUBUS_INNERRADIUS
#define RPOT_MAINTUBUS_INNERRADIUS
Definition: AFP_GeoModelRP.cxx:43
GeoOpticalSurface::polished
@ polished
Definition: GeoOpticalSurface.h:32
AFP_GeoModelFactory::addSiDetector
void addSiDetector(GeoPhysVol *pPhysMotherVol, const char *pszStationName, HepGeom::Transform3D &TransInMotherVolume)
Definition: AFP_GeoModelSID.cxx:42
AFP_GeoModelFactory::m_MapMaterials
std::map< std::string, GeoRef< const GeoMaterial > > m_MapMaterials
Definition: AFP_GeoModelFactory.h:44
AFP_TDCONFIGURATION::fAlpha
double fAlpha
Definition: AFP_ConfigParams.h:83
RPOT_MAINTUBUS_WNDTHICKNESS
#define RPOT_MAINTUBUS_WNDTHICKNESS
Definition: AFP_GeoModelRP.cxx:48
ESTT_FEI4CHIP
@ ESTT_FEI4CHIP
Definition: AFP_ConfigParams.h:17
GeoExtendedMaterial
Definition: GeoExtendedMaterial.h:28
Generated on Thu Nov 7 2024 21:35:38 for ATLAS Offline Software by   doxygen 1.8.18