ATLAS Offline Software
AFP_GeoModelFactory.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "AFP_GeoModelFactory.h"
6 #include "GeoModelKernel/GeoMaterial.h"
7 #include "GeoModelKernel/GeoBox.h"
8 #include "GeoModelKernel/GeoLogVol.h"
9 #include "GeoModelKernel/GeoNameTag.h"
10 #include "GeoModelKernel/GeoPhysVol.h"
11 #include "GeoModelKernel/GeoFullPhysVol.h"
12 #include "GeoModelKernel/GeoTransform.h"
13 #include "GeoModelKernel/GeoAlignableTransform.h"
14 #include "CLHEP/GenericFunctions/AbsFunction.hh"
15 #include "CLHEP/GenericFunctions/Variable.hh"
16 #include "CLHEP/GenericFunctions/Sin.hh"
17 #include "CLHEP/GenericFunctions/Cos.hh"
18 #include "StoreGate/StoreGateSvc.h"
19 
20 #include "GeoModelUtilities/GeoOpticalPhysVol.h"
21 #include "GeoModelInterfaces/StoredMaterialManager.h"
22 #include "GeoModelUtilities/GeoExtendedMaterial.h"
23 #include "GeoModelUtilities/GeoMaterialPropertiesTable.h"
24 #include "GeoModelUtilities/GeoBorderSurfaceContainer.h"
25 #include "AFP_Geometry/AFP_Geometry.h"
26 #include "AFP_Geometry/AFP_constants.h"
27 
28 #include "GeoPrimitives/CLHEPtoEigenConverter.h"
29 
30 #include <iostream>
31 #include <fstream>
32 
33 #include <algorithm>
34 #include <cmath>
35 #include <cstdlib>
36 #include <list>
37 #include <map>
38 #include <string>
39 
40 
41 using namespace Genfun;
42 using namespace CLHEP;
43 
44 AFP_GeoModelFactory::AFP_GeoModelFactory(StoreGateSvc *detStore, AFP_Geometry* pGeometry)
45  :m_pDetectorManager(nullptr), m_pDetectorStore(detStore), m_addSeparationWindow(false)
46 {
47  pGeometry->getCfgParams(&m_CfgParams);
48  m_pGeometry=pGeometry;
49 
50  initializeTDParameters();
51 }
52 
53 
54 AFP_GeoModelFactory::~AFP_GeoModelFactory()
55 {
56  m_CfgParams.clear();
57 }
58 
59 void AFP_GeoModelFactory::defineMaterials()
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 }
218 
219 
220 void AFP_GeoModelFactory::create(GeoPhysVol *world)
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 }
337 
338 const AFP_GeoModelManager* AFP_GeoModelFactory::getDetectorManager() const
339 {
340  return m_pDetectorManager;
341 }
342 
343 
344 void AFP_GeoModelFactory::updatePositions(AFP_BPMCOOLPARAMS* /*pBpmParams*/)
345 {
346 
347 }
GeoOpticalPhysVol
Ensure that the extensions for the Vector3D are properly loaded.
Definition: GeoOpticalPhysVol.h:14
AFP_GeoModelFactory::~AFP_GeoModelFactory
~AFP_GeoModelFactory()
Definition: AFP_GeoModelFactory.cxx:54
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PhysicalConstants.STP_Temperature
float STP_Temperature
Definition: PhysicalConstants.py:119
GeoMaterialPropertiesTable::AddProperty
void AddProperty(const char *key, double *PhotonMomenta, double *PropertyValues, int NumEntries)
Definition: GeoMaterialPropertiesTable.cxx:31
AFP_GeoModelFactory::AFP_GeoModelFactory
AFP_GeoModelFactory(StoreGateSvc *pDetStore, AFP_Geometry *pGeometry)
Definition: AFP_GeoModelFactory.cxx:44
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
GeoExtendedMaterial.h
AFP_constants.h
DMTest::C
C_v1 C
Definition: C.h:26
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
GeoOpticalPhysVol.h
ESE_RPOT
@ ESE_RPOT
Definition: AFP_ConfigParams.h:16
stateSolid
@ stateSolid
Definition: GeoExtendedMaterial.h:25
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
GeoExtendedMaterial::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(GeoMaterialPropertiesTable *MPT)
Definition: GeoExtendedMaterial.h:73
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
AFP_GeoModelFactory.h
GeoBorderSurfaceContainer.h
AFP_GeoModelFactory::m_CfgParams
AFP_CONFIGURATION m_CfgParams
Definition: AFP_GeoModelFactory.h:59
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_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::m_pGeometry
AFP_Geometry * m_pGeometry
Definition: AFP_GeoModelFactory.h:60
H
#define H(x, y, z)
Definition: MD5.cxx:114
AFP_GeoModelManager::addTreeTop
void addTreeTop(const PVLink &)
Definition: AFP_GeoModelManager.cxx:27
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
CLHEP
STD'S.
Definition: IAtRndmGenSvc.h:19
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
AFP_Geometry::getStationElementTransform
HepGeom::Transform3D getStationElementTransform(const char *pszStationName, eStationElement eElement, const int nPlateID=-1) const
Definition: AFP_Geometry.cxx:81
AFP_GeoModelFactory::create
virtual void create(GeoPhysVol *world)
Definition: AFP_GeoModelFactory.cxx:220
AFP_GeoModelFactory::getDetectorManager
virtual const AFP_GeoModelManager * getDetectorManager() const
Definition: AFP_GeoModelFactory.cxx:338
AFP_BPMCOOLPARAMS
Definition: AFP_GeoModelFactory.h:17
AFP_Geometry
Definition: AFP_Geometry.h:20
CLHEPtoEigenConverter.h
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
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
StoredMaterialManager.h
AFP_GeoModelManager
Definition: AFP_GeoModelManager.h:11
GeoMaterialPropertiesTable.h
AFP_GeoModelFactory::defineMaterials
void defineMaterials()
Definition: AFP_GeoModelFactory.cxx:59
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::ToF_ColumnsCnt
static constexpr double ToF_ColumnsCnt
Definition: AFP_constants.h:82
hydjet.StoreGateSvc
StoreGateSvc
Definition: hydjet.minbias.pbpb5520.r12345.job.py:40
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:110
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
AFP_GeoModelFactory::updatePositions
void updatePositions(AFP_BPMCOOLPARAMS *pBpmParams)
Definition: AFP_GeoModelFactory.cxx:344
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
mole
#define mole
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
ESE_SID
@ ESE_SID
Definition: AFP_ConfigParams.h:16
GeoMaterialPropertiesTable
Definition: GeoMaterialPropertiesTable.h:20
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
StoreGateSvc.h
AFP_Geometry.h
Genfun
Definition: AtlasBComponent.cxx:12
GeoExtendedMaterial
Definition: GeoExtendedMaterial.h:28
Generated on Thu Nov 7 2024 21:09:36 for ATLAS Offline Software by   doxygen 1.8.18