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 {}
 
GeoIntrusivePtr< GeoOpticalSurface > m_pOpticalSurface {}
 
GeoIntrusivePtr< GeoOpticalSurface > m_pReflectionOptSurface {}
 

Detailed Description

Definition at line 38 of file AFP_GeoModelFactory.h.

Constructor & Destructor Documentation

◆ AFP_GeoModelFactory() [1/2]

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

Definition at line 40 of file AFP_GeoModelFactory.cxx.

41  :m_pDetectorStore(detStore)
42 {
43  pGeometry->getCfgParams(&m_CfgParams);
44  m_pGeometry=pGeometry;
45 
46  initializeTDParameters();
47 }

◆ ~AFP_GeoModelFactory()

AFP_GeoModelFactory::~AFP_GeoModelFactory ( )

Definition at line 50 of file AFP_GeoModelFactory.cxx.

51 {
52  m_CfgParams.clear();
53 }

◆ 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 210 of file AFP_GeoModelTD.cxx.

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

◆ 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 246 of file AFP_GeoModelTD.cxx.

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

◆ 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 91 of file AFP_GeoModelTD.cxx.

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

◆ addSiDetector()

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

Definition at line 41 of file AFP_GeoModelSID.cxx.

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

◆ addTimingDetector()

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

Definition at line 58 of file AFP_GeoModelTD.cxx.

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

◆ create()

void AFP_GeoModelFactory::create ( GeoPhysVol *  world)
virtual

Definition at line 216 of file AFP_GeoModelFactory.cxx.

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

◆ createSolidSIDPlate()

GeoShape * AFP_GeoModelFactory::createSolidSIDPlate ( )
private

Definition at line 111 of file AFP_GeoModelSID.cxx.

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

◆ defineMaterials()

void AFP_GeoModelFactory::defineMaterials ( )
private

Definition at line 55 of file AFP_GeoModelFactory.cxx.

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

◆ 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 334 of file AFP_GeoModelFactory.cxx.

335 {
336  return m_pDetectorManager;
337 }

◆ getLQBarDimensions()

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

◆ initializeTDParameters()

void AFP_GeoModelFactory::initializeTDParameters ( )
private

Definition at line 45 of file AFP_GeoModelTD.cxx.

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

◆ operator=()

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

◆ updatePositions()

void AFP_GeoModelFactory::updatePositions ( AFP_BPMCOOLPARAMS *  pBpmParams)

Definition at line 340 of file AFP_GeoModelFactory.cxx.

341 {
342 
343 }

Member Data Documentation

◆ m_addSeparationWindow

const bool AFP_GeoModelFactory::m_addSeparationWindow {}
private

Definition at line 69 of file AFP_GeoModelFactory.h.

◆ m_CfgParams

AFP_CONFIGURATION AFP_GeoModelFactory::m_CfgParams
private

Definition at line 67 of file AFP_GeoModelFactory.h.

◆ m_MapMaterials

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

Definition at line 53 of file AFP_GeoModelFactory.h.

◆ m_MapShape

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

Definition at line 66 of file AFP_GeoModelFactory.h.

◆ m_pDetectorManager

AFP_GeoModelManager* AFP_GeoModelFactory::m_pDetectorManager {}
private

Definition at line 62 of file AFP_GeoModelFactory.h.

◆ m_pDetectorStore

StoreGateSvc* AFP_GeoModelFactory::m_pDetectorStore {}
private

Definition at line 63 of file AFP_GeoModelFactory.h.

◆ m_pGeometry

AFP_Geometry* AFP_GeoModelFactory::m_pGeometry {}
private

Definition at line 68 of file AFP_GeoModelFactory.h.

◆ m_pOpticalSurface

GeoIntrusivePtr<GeoOpticalSurface> AFP_GeoModelFactory::m_pOpticalSurface {}
private

Definition at line 77 of file AFP_GeoModelFactory.h.

◆ m_pReflectionOptSurface

GeoIntrusivePtr<GeoOpticalSurface> AFP_GeoModelFactory::m_pReflectionOptSurface {}
private

Definition at line 78 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.mm
float mm
Definition: SystemOfUnits.py:98
vtune_athena.format
format
Definition: vtune_athena.py:14
RPOT_MAINTUBUS_BPTHICKNESS
#define RPOT_MAINTUBUS_BPTHICKNESS
Definition: AFP_GeoModelRP.cxx:45
python.PhysicalConstants.STP_Temperature
float STP_Temperature
Definition: PhysicalConstants.py:131
RPOT_MAINTUBUS_THICKNESS
#define RPOT_MAINTUBUS_THICKNESS
Definition: AFP_GeoModelRP.cxx:44
AFP_GeoModelFactory::m_pReflectionOptSurface
GeoIntrusivePtr< GeoOpticalSurface > m_pReflectionOptSurface
Definition: AFP_GeoModelFactory.h:78
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:58
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_GeoModelFactory::m_pOpticalSurface
GeoIntrusivePtr< GeoOpticalSurface > m_pOpticalSurface
Definition: AFP_GeoModelFactory.h:77
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:91
AFP_GeoModelFactory::createSolidSIDPlate
GeoShape * createSolidSIDPlate()
Definition: AFP_GeoModelSID.cxx:111
AFP_GeoModelFactory::m_CfgParams
AFP_CONFIGURATION m_CfgParams
Definition: AFP_GeoModelFactory.h:67
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:62
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:210
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:68
python.SystemOfUnits.eV
float eV
Definition: SystemOfUnits.py:173
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_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:246
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:24
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:45
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
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
AFPTOF_LBARDIMENSIONS
Definition: AFP_ConfigParams.h:61
AFP_GeoModelFactory::defineMaterials
void defineMaterials()
Definition: AFP_GeoModelFactory.cxx:55
RPOT_FLOOR_WNDFACET
#define RPOT_FLOOR_WNDFACET
Definition: AFP_GeoModelRP.cxx:55
AFP_GeoModelFactory::m_pDetectorStore
StoreGateSvc * m_pDetectorStore
Definition: AFP_GeoModelFactory.h:63
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:69
RPOT_FLOOR_THICKNESS
#define RPOT_FLOOR_THICKNESS
Definition: AFP_GeoModelRP.cxx:52
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:109
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:41
AFP_GeoModelFactory::m_MapMaterials
std::map< std::string, GeoRef< const GeoMaterial > > m_MapMaterials
Definition: AFP_GeoModelFactory.h:53
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
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
GeoExtendedMaterial
Definition: GeoExtendedMaterial.h:28
Generated on Mon Sep 29 2025 21:26:33 for ATLAS Offline Software by   doxygen 1.8.18