Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
Tile::TileVolumeBuilder Class Referencefinal

#include <TileVolumeBuilder.h>

Inheritance diagram for Tile::TileVolumeBuilder:
Collaboration diagram for Tile::TileVolumeBuilder:

Public Member Functions

 TileVolumeBuilder (const std::string &, const std::string &, const IInterface *)
 AlgTool style constructor. More...
 
virtual ~TileVolumeBuilder ()
 Destructor. More...
 
virtual StatusCode initialize () override final
 AlgTool initialize method. More...
 
virtual std::vector< Trk::TrackingVolume * > * trackingVolumes (const CaloDetDescrManager &caloDDM, const GeoAlignmentStore *geoAlign) const override final
 TrackingVolumeBuilder interface method - returns vector of Volumes. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
 DeclareInterfaceID (ICaloTrackingVolumeBuilder, 1, 0)
 Creates the InterfaceID and interfaceID() method. More...
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void printInfo (const GeoPVConstLink &pv) const
 
void printChildren (const GeoPVConstLink &pv, int igen, const Amg::Transform3D &trIn) const
 
void throwIntoGarbage (std::unique_ptr< Trk::Material > mat) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static void printCheckResult (MsgStream &log, const Trk::TrackingVolume *vol)
 

Private Attributes

const TileDetDescrManager * m_tileMgr
 Calo DetDescrMgr. More...
 
std::string m_tileMgrLocation
 Location of the CaloDetDescrMgr. More...
 
ToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
 Helper Tool to create TrackingVolumes. More...
 
ToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
 Second helper for volume creation. More...
 
double m_tileBarrelEnvelope
 envelope Cover of the Barrel More...
 
bool m_useCaloSurfBuilder
 if true use DetDescr based layering, if false use biequidistant layering More...
 
unsigned int m_tileBarrelLayersPerSampling
 if m_useCaloSurfBuilder == true, number of layers per dead material region or sampling More...
 
ToolHandle< ICaloSurfaceBuilder > m_surfBuilder
 tool required for definition of active volumes More...
 
bool m_forceSymmetry
 forces volume symmetry between negative/positive part More...
 
std::mutex m_garbageMutex
 
std::vector< std::unique_ptr< Trk::Material > > m_garbage ATLAS_THREAD_SAFE
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

The TileVolumeBuilder builds the TrackingVolumes for

Author
Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

dense volume description & layer/cell navigation

Author
sarka.nosp@m..tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 57 of file TileVolumeBuilder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileVolumeBuilder()

Tile::TileVolumeBuilder::TileVolumeBuilder ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

AlgTool style constructor.

Definition at line 60 of file TileVolumeBuilder.cxx.

60  :
61  AthAlgTool(t,n,p),
62  m_tileMgr(nullptr),
63  m_tileMgrLocation("Tile"),
64  m_trackingVolumeHelper("Trk::TrackingVolumeHelper/TrackingVolumeHelper"),
65  m_trackingVolumeCreator("Trk::CylinderVolumeCreator/TrackingVolumeCreator"),
66  m_tileBarrelEnvelope(25.*mm),
67  m_useCaloSurfBuilder(true),
68  m_tileBarrelLayersPerSampling(1),
69  m_surfBuilder("CaloSurfaceBuilder"),
70  m_forceSymmetry(true)
71 
72 {
73  declareInterface<Trk::ICaloTrackingVolumeBuilder>(this);
74  // declare the properties via Python
75  declareProperty("TileDetManagerLocation", m_tileMgrLocation);
76  // layers and general setup
77  declareProperty("BarrelEnvelopeCover", m_tileBarrelEnvelope);
78  declareProperty("ForceVolumeSymmetry", m_forceSymmetry);
79  // helper tools
80  declareProperty("TrackingVolumeHelper", m_trackingVolumeHelper);
81  declareProperty("TrackingVolumeCreator", m_trackingVolumeCreator);
82  declareProperty("UseCaloSurfBuilder", m_useCaloSurfBuilder);
83  declareProperty("BarrelLayersPerSampling", m_tileBarrelLayersPerSampling);
84  declareProperty("CaloSurfaceBuilder", m_surfBuilder);
85 }

◆ ~TileVolumeBuilder()

Tile::TileVolumeBuilder::~TileVolumeBuilder ( )
virtualdefault

Destructor.

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ DeclareInterfaceID()

Trk::ICaloTrackingVolumeBuilder::DeclareInterfaceID ( ICaloTrackingVolumeBuilder  ,
1  ,
0   
)
inherited

Creates the InterfaceID and interfaceID() method.

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ initialize()

StatusCode Tile::TileVolumeBuilder::initialize ( )
finaloverridevirtual

AlgTool initialize method.

Definition at line 94 of file TileVolumeBuilder.cxx.

95 {
96  // get Tile Detector Description Manager
97  if (detStore()->retrieve(m_tileMgr, m_tileMgrLocation).isFailure()){
98  ATH_MSG_FATAL( "Could not get TileDetDescrManager! Tile TrackingVolumes will not be built" );
99  return StatusCode::FAILURE;
100  }
101 
102  // Retrieve the tracking volume helper -------------------------------------------------
103  if (m_trackingVolumeHelper.retrieve().isFailure())
104  {
105  ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeHelper );
106  return StatusCode::FAILURE;
107  } else
108  ATH_MSG_INFO( "Retrieved tool " << m_trackingVolumeHelper );
109 
110  // Retrieve the second volume creator
111  if (m_trackingVolumeCreator.retrieve().isFailure()){
112  ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeCreator );
113  return StatusCode::FAILURE;
114  } else
115  ATH_MSG_INFO( "Retrieved tool " << m_trackingVolumeCreator );
116 
117  if(m_surfBuilder.retrieve().isFailure())
118  {
119  ATH_MSG_FATAL( "Failed to retrieve tool " << m_surfBuilder );
120  return StatusCode::FAILURE;
121  } else
122  ATH_MSG_INFO( "Retrieved tool " << m_surfBuilder );
123 
124  ATH_MSG_INFO( " initialize() successful" );
125  return StatusCode::SUCCESS;
126 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ printCheckResult()

void Tile::TileVolumeBuilder::printCheckResult ( MsgStream &  log,
const Trk::TrackingVolume *  vol 
)
staticprivate

Definition at line 799 of file TileVolumeBuilder.cxx.

800 {
801  if (vol) log << "... ok" << endmsg;
802  else log << "... missing" << endmsg;
803 }

◆ printChildren()

void Tile::TileVolumeBuilder::printChildren ( const GeoPVConstLink &  pv,
int  igen,
const Amg::Transform3D &  trIn 
) const
private

Definition at line 817 of file TileVolumeBuilder.cxx.

818 {
819  // subcomponents
820  unsigned int nc = pv->getNChildVols();
821  igen++;
822  std::string cname;
823  for (unsigned int ic=0; ic<nc; ic++) {
824  Amg::Transform3D transf = trIn*pv->getXToChildVol(ic);
825 
826  //
827  //std::cout << " dumping transform to subcomponent" << std::endl;
828  //std::cout << transf[0][0]<<"," <<transf[0][1]<<"," <<transf[0][2]<<","<<transf[0][3] << std::endl;
829  //std::cout << transf[1][0]<<"," <<transf[1][1]<<"," <<transf[1][2]<<","<<transf[1][3] << std::endl;
830  //std::cout << transf[2][0]<<"," <<transf[2][1]<<"," <<transf[2][2]<<","<<transf[2][3] << std::endl;
831  //
832  const PVConstLink cv = pv->getChildVol(ic);
833  const GeoLogVol* clv = cv->getLogVol();
834  std::cout << " ";
835  std::cout << "subcomponent:"<<igen<<":"<<ic<<":"<<clv->getName()<<", made of"<<clv->getMaterial()->getName()<<","<<clv->getShape()->type()
836  <<std::endl;
837  std::cout << "position:"<< "R:"<<transf.translation().perp()<<",phi:"<< transf.translation().phi()<<",x:"<<transf.translation().x()<<",y:"<<transf.translation().y()<<",z:"<<transf.translation().z()<<std::endl;
838  const GeoTrd* trd=dynamic_cast<const GeoTrd*> (clv->getShape());
839  if (trd) std::cout<<"trddim:"<< trd->getXHalfLength1()<<","<<trd->getXHalfLength2()<<","<<trd->getYHalfLength1()<<","<<trd->getYHalfLength2()<<","<<trd->getZHalfLength()<< std::endl;
840  const GeoTubs* tub=dynamic_cast<const GeoTubs*> (clv->getShape());
841  if (tub) std::cout<<"tubdim:"<< tub->getRMin()<<","<<tub->getRMax()<<","<<tub->getZHalfLength()<< std::endl;
842  const GeoPcon* con=dynamic_cast<const GeoPcon*> (clv->getShape());
843  if (con) {
844  const unsigned int nPlanes=con->getNPlanes();
845  for (unsigned int i=0; i<nPlanes; i++) {
846  std::cout<<"polycone:"<<i<<":"<< con->getRMinPlane(i)<<","<<con->getRMaxPlane(i)<<","<<con->getZPlane(i)<< std::endl;
847  }
848  }
849 
850  if (ic==0 || cname != clv->getName() ) {
851  //m_geoShapeConverter->decodeShape(clv->getShape());
852  printChildren(cv,igen,transf);
853  cname = clv->getName();
854  }
855  }
856 
857 }

◆ printInfo()

void Tile::TileVolumeBuilder::printInfo ( const GeoPVConstLink &  pv) const
private

Definition at line 807 of file TileVolumeBuilder.cxx.

808 {
809  const GeoLogVol* lv = pv->getLogVol();
810  std::cout << "New Tile Object:"<<lv->getName()<<", made of"<<lv->getMaterial()->getName()<<","<<lv->getShape()->type()<<std::endl;
811  //m_geoShapeConverter->decodeShape(lv->getShape());
812  int igen=0;
813  Amg::Transform3D transf = pv->getX();
814  printChildren(pv,igen,transf);
815 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ throwIntoGarbage()

void Tile::TileVolumeBuilder::throwIntoGarbage ( std::unique_ptr< Trk::Material >  mat) const
private

Definition at line 860 of file TileVolumeBuilder.cxx.

861 {
862  std::scoped_lock lock (m_garbageMutex);
863  m_garbage.push_back (std::move (mat));
864 }

◆ trackingVolumes()

std::vector< Trk::TrackingVolume * > * Tile::TileVolumeBuilder::trackingVolumes ( const CaloDetDescrManager &  caloDDM,
const GeoAlignmentStore *  geoAlign 
) const
finaloverridevirtual

TrackingVolumeBuilder interface method - returns vector of Volumes.

Implements Trk::ICaloTrackingVolumeBuilder.

Definition at line 129 of file TileVolumeBuilder.cxx.

131 {
132  // the return vector
133  std::vector<Trk::TrackingVolume*>* tileTrackingVolumes = new std::vector<Trk::TrackingVolume*>;
134  // the converter helpers
135  //Trk::GeoShapeConverter geoShapeToVolumeBounds;
136  //Trk::GeoMaterialConverter geoMaterialToMaterialProperties;
137  // dummy material
138  Trk::Material tileMaterial;
139 
140  // dimensions
141  double tileZ = 0.;
142  double gapZ = 0.;
143  // ITC hardcoded : simple shortcut (needs resizing anyway )
144  double plug1Z = 3405.;
145  double plug2Z = 3512.075;
146  double plug1R = 3440.;
147  double plug2R = 2959.;
148  double plug1hZ = 154.5;
149  double plug2hZ = 47.425;
150 
151  // The Volumes To be Created ( by parsing geoModel ) ===========
152  Trk::TrackingVolume* tileBarrel = nullptr;
153  Trk::TrackingVolume* tileGirder = nullptr;
154 
155  Trk::TrackingVolume* tilePositiveExtendedBarrel = nullptr;
156  Trk::TrackingVolume* tileNegativeExtendedBarrel = nullptr;
157 
158  // The Volumes To be Created ( Gap Volumes ) ====================
159  Trk::TrackingVolume* tileBarrelPositiveFingerGap = nullptr;
160  Trk::TrackingVolume* tileBarrelNegativeFingerGap = nullptr;
161  Trk::TrackingVolume* tilePositiveFingerGap = nullptr;
162  Trk::TrackingVolume* tileNegativeFingerGap = nullptr;
163 
164  // The Bounds To be Assigned (for resizing) ====================
165  Trk::CylinderVolumeBounds* tileBarrelBounds = nullptr;
166  std::unique_ptr<Trk::CylinderVolumeBounds> tileBarrelGirderBounds;
167 
168  Trk::CylinderVolumeBounds tilePositiveExtendedBarrelBounds;
169  Trk::CylinderVolumeBounds* itcPlug1Bounds = nullptr;
170  Trk::CylinderVolumeBounds* itcPlug2Bounds = nullptr;
171  Trk::CylinderVolumeBounds* gapBounds = nullptr;
172 
173  // dummy objects
174  Trk::LayerArray* dummyLayers = nullptr;
175  Trk::TrackingVolumeArray* dummyVolumes = nullptr;
176 
177  std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> entrySurf =
178  m_surfBuilder->entrySurfaces(&caloDDM);
179  std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> exitSurf =
180  m_surfBuilder->exitSurfaces(&caloDDM);
181 
182  // averaged material properties
183  auto barrelProperties = std::make_unique<Trk::Material>(22.7, 212., 45.8, 21.4, 0.0062);
184  auto extendedBarrelProperties = std::make_unique<Trk::Material>(22.7, 210., 45.8, 21.4, 0.0062);
185  // material properties with layer encoding - to be defined later
186  const Trk::BinnedMaterial* barrelMaterialBinned = nullptr;
187  const Trk::BinnedMaterial* extendedMaterialBinned = nullptr;
188 
189  Trk::Material girderProperties = Trk::Material(28.6, 272.5, 40.4, 19., 0.0049);
190  Trk::Material extendedGirderProperties = Trk::Material(27.9, 266.4, 41., 19.2, 0.005);
191  Trk::Material fingerProperties = Trk::Material(46., 426.6, 34.2, 16.2, 0.0032);
192 
193  unsigned int numTreeTops = m_tileMgr->getNumTreeTops();
194  ATH_MSG_DEBUG( "Retrieved " << numTreeTops << " tree tops from the TileDetDescrManager. " );
195 
196  // layer material can be adjusted here
197  std::vector<Trk::IdentifiedMaterial> matTB;
198  int baseID = Trk::GeometrySignature(Trk::Calo)*1000 + 12;
199  matTB.emplace_back(barrelProperties.get(),0);
200  matTB.emplace_back(barrelProperties.get(),baseID);
201  matTB.emplace_back(barrelProperties.get(),baseID+1);
202  matTB.emplace_back(barrelProperties.get(),baseID+2);
203 
204  // material index
205  std::vector<size_t> ltb{0,1,2,3};
206 
207  // layer material can be adjusted here
208  std::vector<Trk::IdentifiedMaterial> matETB;
209  baseID = Trk::GeometrySignature(Trk::Calo)*1000 + 18;
210  matETB.emplace_back(extendedBarrelProperties.get(),0);
211  matETB.emplace_back(extendedBarrelProperties.get(),baseID);
212  matETB.emplace_back(extendedBarrelProperties.get(),baseID+1);
213  matETB.emplace_back(extendedBarrelProperties.get(),baseID+2);
214 
215  // layer material can be adjusted here
216  //Trk::MaterialProperties barrelFingerGapProperties = Trk::MaterialProperties(1., 130./0.35, 0.003*pow(0.35,3),30.);
217  Trk::Material barrelFingerGapProperties(353., 2254., 20.7, 10., 0.00057);
218 
219  //Trk::MaterialProperties fingerGapProperties = Trk::MaterialProperties(1., 88./0.1, 0.003*pow(0.1,3),30.);
220  Trk::Material fingerGapProperties(552., 3925., 16.4, 8.1, 0.00034);
221 
222  for (unsigned int itreetop = 0; itreetop<numTreeTops; ++itreetop){
223  PVConstLink currentVPhysVolLink = m_tileMgr->getTreeTop(itreetop);
224 
225  // const GeoVPhysVol* top = &(*(m_tileMgr->getTreeTop(itreetop)));
226  //GeoVolumeCursor vol (top);
227  //while (!vol.atEnd()) {
228  // const GeoVPhysVol* cv = &(*(vol.getVolume()));
229  // printInfo(cv);
230  //}
231 
232  const GeoLogVol* currentLogVol = currentVPhysVolLink->getLogVol();
233 
234  unsigned int currentChilds = currentVPhysVolLink->getNChildVols();
235 
236  ATH_MSG_DEBUG( "Processing " << currentLogVol->getName() << "... has "
237  << currentChilds << " childs." );
238  const GeoShape* currentShape = currentLogVol->getShape();
239  ATH_MSG_VERBOSE( " -> the shape is " << currentShape->type() );
240  std::vector<double> zboundaries;
241 
242  ATH_MSG_DEBUG( "Start looping over childs. " );
243  // the loop over the childs
244  for (unsigned int ichild = 0; ichild < currentChilds; ++ichild){
245 
246  PVConstLink currentChildLink = currentVPhysVolLink->getChildVol(ichild);
247  //printInfo(currentChildLink);
248  const GeoLogVol* childLogVol = currentChildLink->getLogVol();
249  const GeoShape* childShape = childLogVol->getShape();
250  ATH_MSG_VERBOSE( " Child: " << childLogVol->getName() << " has shape " << childShape->type() );
251 
252  const GeoTubs* currentTubs = dynamic_cast<const GeoTubs*>(childShape);
253  Trk::CylinderVolumeBounds* childCylVolBounds = currentTubs ? Trk::GeoShapeConverter::convert(currentTubs).release() : nullptr;
254  // get the transform
255  GeoTrf::Transform3D childTransform = currentVPhysVolLink->getXToChildVol(ichild);
256  double childZposition = childTransform.translation().z();
257 
258  if (childCylVolBounds){
259  // screen output
260  ATH_MSG_VERBOSE( " ---> CylinderVolumeBounds created as: " );
261  ATH_MSG_VERBOSE( " ---> Position in z: " << childTransform.translation().z() );
262  ATH_MSG_VERBOSE( *childCylVolBounds );
263 
264  // retrieve split radius from the TileBar2 exit surface
265  double depth = exitSurf[CaloCell_ID::TileBar2].first->bounds().r();
266 
267  switch (itreetop){
268 
269  case 0 : { // Tile Barrel case ==================================================================
270 
271  // the centered one is the TileBarrel
272  if ( fabs(childZposition)< 100.*mm ){
273  //depth is where we split childCylVolBounds
274  tileBarrelBounds = new Trk::CylinderVolumeBounds(childCylVolBounds->innerRadius(),depth,childCylVolBounds->halflengthZ());
275 
276  // assign Bounds
277  tileBarrelGirderBounds = make_unique<Trk::CylinderVolumeBounds>(depth,childCylVolBounds->outerRadius(),childCylVolBounds->halflengthZ());
278 
279  Amg::Transform3D* align=nullptr; // no alignment given yet
280 
281  // construct bin utilities
282  std::vector<float> steps;
283  steps.push_back(childCylVolBounds->innerRadius());
284  steps.push_back(entrySurf[CaloCell_ID::TileBar0].first->bounds().r());
285  steps.push_back(entrySurf[CaloCell_ID::TileBar1].first->bounds().r());
286  steps.push_back(entrySurf[CaloCell_ID::TileBar2].first->bounds().r());
287  steps.push_back(depth);
288  Trk::BinUtility* rBU = new Trk::BinUtility(steps, Trk::open, Trk::binR);
289 
290  barrelMaterialBinned = new Trk::BinnedMaterial(barrelProperties.get(),rBU,ltb,matTB);
291 
292  tileBarrel = new Trk::AlignableTrackingVolume(nullptr,align,
293  tileBarrelBounds,
294  barrelMaterialBinned,
295  12,
296  "Calo::Detectors::Tile::Barrel");
297  }
298  } break;
299 
300  default : { // Tile Extended Barrel ==================================================================
301 
302  std::string volumeName;
303  std::string girderName;
304  std::vector<double> girderLayerRadius;
305  std::vector<double> layerRadius;
306  std::vector<double> layerEnvelope;
307  Trk::CylinderVolumeBounds* tileExtendedBounds = nullptr;
308  bool tileExtendedBoundsUsed = false;
309  std::unique_ptr<Trk::CylinderVolumeBounds> gapVolBounds;
310 
311  // prepare for the Extended Barrel
312  if (childCylVolBounds->halflengthZ() > 1000.){
313  volumeName = childZposition > 0. ?
314  "Calo::Detectors::Tile::PositiveExtendedBarrel" : "Calo::Detectors::Tile::NegativeExtendedBarrel";
315 
316  //depth is where we split childCylVolBounds
317  tileExtendedBounds = new Trk::CylinderVolumeBounds(childCylVolBounds->innerRadius(),depth,childCylVolBounds->halflengthZ());
318 
319  } else if (childCylVolBounds->halflengthZ() > 100.){
320  // prepare for the EBarrel Finger : (ST) : merge with combined girder
321  //tileFingerBounds = new Trk::CylinderVolumeBounds(depth,childCylVolBounds->outerRadius(),childCylVolBounds->halflengthZ());
322 
323  } else if ( childLogVol->getName()=="Gap" && !gapBounds ) {
324 
325  gapVolBounds = make_unique<Trk::CylinderVolumeBounds>(childCylVolBounds->innerRadius(),childCylVolBounds->outerRadius(),
326  childCylVolBounds->halflengthZ());
327 
328  gapZ = fabs(childZposition);
329 
330  } else {
331  ATH_MSG_VERBOSE( " ---> This Volume is not gonna built !" );
332  break;
333  }
334 
335  // only account for misalignment along z
336  Amg::Vector3D childPosition(0.,0.,childZposition);
337  Trk::TrackingVolume* tileExtendedTrackingVolume = nullptr;
338  Amg::Transform3D* align=nullptr; // no alignment given yet
339 
340  if(m_useCaloSurfBuilder && childCylVolBounds->halflengthZ() > 1000.){
341 
342  // get some output
343  ATH_MSG_VERBOSE ( "[C1] Creating TrackingVolume '" << volumeName );
344 
345  // construct bin utilities
346  std::vector<float> steps;
347  steps.push_back(tileExtendedBounds->innerRadius());
348  steps.push_back(entrySurf[CaloCell_ID::TileExt0].first->bounds().r());
349  steps.push_back(entrySurf[CaloCell_ID::TileExt1].first->bounds().r());
350  steps.push_back(entrySurf[CaloCell_ID::TileExt2].first->bounds().r());
351  steps.push_back(tileExtendedBounds->outerRadius());
352  Trk::BinUtility* eBU = new Trk::BinUtility(steps, Trk::open, Trk::binR);
353 
354  extendedMaterialBinned = new Trk::BinnedMaterial(extendedBarrelProperties.get(),eBU,ltb,matETB);
355 
356  tileExtendedTrackingVolume = new Trk::AlignableTrackingVolume(new Amg::Transform3D(Amg::Translation3D(childPosition)),
357  align,
358  tileExtendedBounds,
359  extendedMaterialBinned,
360  18,
361  volumeName);
362  tileExtendedBoundsUsed = true;
363 
364  } else {
365  if ( gapVolBounds ) {
366  gapBounds = gapVolBounds.release();
367 
368  } else if (tileExtendedBounds) {
369 
370  // construct bin utilities
371  std::vector<float> steps;
372  steps.push_back(tileExtendedBounds->innerRadius());
373  steps.push_back(entrySurf[CaloCell_ID::TileExt0].first->bounds().r());
374  steps.push_back(entrySurf[CaloCell_ID::TileExt1].first->bounds().r());
375  steps.push_back(entrySurf[CaloCell_ID::TileExt2].first->bounds().r());
376  steps.push_back(tileExtendedBounds->outerRadius());
377  Trk::BinUtility* eBU = new Trk::BinUtility(steps, Trk::open, Trk::binR);
378 
379  extendedMaterialBinned = new Trk::BinnedMaterial(extendedBarrelProperties.get(),eBU,ltb,matETB);
380 
381  tileExtendedTrackingVolume = new Trk::AlignableTrackingVolume(new Amg::Transform3D(Amg::Translation3D(childPosition)),
382  align,
383  tileExtendedBounds,
384  extendedMaterialBinned,
385  18,
386  volumeName);
387  tileExtendedBoundsUsed = true;
388  }
389  }
390  // and assign it to the right one
391  if (childCylVolBounds->halflengthZ() > 1000.){
392  if (childZposition > 0.) {
393  tilePositiveExtendedBarrel = tileExtendedTrackingVolume;
394  tilePositiveExtendedBarrelBounds = *tileExtendedBounds;
395  // tileExtendedBoundsUsed = true; - this line is not needed, we copy everything from *tileExtendedBounds to tilePositiveExtendedBarrelBounds
396  } else {
397  tileNegativeExtendedBarrel = tileExtendedTrackingVolume;
398  }
399  } else if (childCylVolBounds->halflengthZ() > 100.) {
400  tileZ = fabs(childZposition)+childCylVolBounds->halflengthZ();
401  }
402  if (!tileExtendedBoundsUsed)
403  delete tileExtendedBounds;
404  } break;
405  } // end of switch
406  } // end of ? cylVolBounds
407  delete childCylVolBounds;
408  } //end of ichild loop
409  } // end of treetop loop
410 
411  if (!gapBounds) std::abort();
412  if (!tileBarrelGirderBounds) std::abort();
413  if (!tilePositiveExtendedBarrel) std::abort();
414  if (!tileNegativeExtendedBarrel) std::abort();
415 
416  ATH_MSG_DEBUG( "TileDetDescrManager parsed successfully! " );
417 
418  // combined girder volume
419  {
420  auto tileGirderBounds = std::make_unique<Trk::CylinderVolumeBounds>
421  (tileBarrelGirderBounds->innerRadius(),
422  tileBarrelGirderBounds->outerRadius(),
423  tileZ);
424 
425  tileGirder =new Trk::TrackingVolume(nullptr,
426  tileGirderBounds.release(),
427  girderProperties,
428  dummyLayers, dummyVolumes,
429  "Calo::Girder::TileCombined");
430  }
431 
432  // build the gap volumes ( crack done by CaloTG )
433  double tileExtZ = tilePositiveExtendedBarrel->center().z()-tilePositiveExtendedBarrelBounds.halflengthZ();
434 
435  // binned material for ITC :
436  std::vector<Trk::IdentifiedMaterial> matITC;
437  // layer material can be adjusted here
438  baseID = Trk::GeometrySignature(Trk::Calo)*1000;
439  matITC.emplace_back(barrelProperties.get(),baseID+15);
440  matITC.emplace_back(barrelProperties.get(),baseID+16);
441  matITC.emplace_back(barrelProperties.get(),baseID+17);
442 
443  // ITCPlug1
444  double p1Z = 0.5*(plug1Z-plug1hZ+tileExtZ);
445  double hp1Z = 0.5*(tileExtZ-plug1Z+plug1hZ);
446  itcPlug1Bounds = new Trk::CylinderVolumeBounds(plug1R,
447  tileBarrelBounds->outerRadius(),
448  hp1Z);
449 
450  Amg::Vector3D itcP1Pos(0.,0.,p1Z);
451  Amg::Vector3D itcP1Neg(0.,0.,-p1Z);
452  Amg::Transform3D* itcP1PosTransform = new Amg::Transform3D(Amg::Translation3D(itcP1Pos));
453  Amg::Transform3D* itcP1NegTransform = new Amg::Transform3D(Amg::Translation3D(itcP1Neg));
454 
455 
456  std::vector<size_t> dummylay(1,1);
457  std::vector<float> bpsteps{float(plug1R), float(tileBarrelBounds->outerRadius())};
458  Trk::BinUtility* rBU = new Trk::BinUtility(bpsteps, Trk::open, Trk::binR);
459  Trk::BinUtility* rBUc = rBU->clone();
460  const Trk::BinnedMaterial* plug1MatPos = new Trk::BinnedMaterial(barrelProperties.get(),rBU,dummylay,matITC);
461  const Trk::BinnedMaterial* plug1MatNeg = new Trk::BinnedMaterial(barrelProperties.get(),rBUc,dummylay,matITC);
462 
463  Amg::Transform3D* align=nullptr;
464 
465  Trk::AlignableTrackingVolume* itcPlug1Pos = new Trk::AlignableTrackingVolume(itcP1PosTransform, align,
466  itcPlug1Bounds,
467  plug1MatPos,
468  16,
469  "Calo::Detectors::Tile::ITCPlug1Pos");
470 
471  Trk::AlignableTrackingVolume* itcPlug1Neg = new Trk::AlignableTrackingVolume(itcP1NegTransform, align,
472  itcPlug1Bounds->clone(),
473  plug1MatNeg,
474  16,
475  "Calo::Detectors::Tile::ITCPlug1Neg");
476 
477  //std::cout <<"ITC Plug1 ok:"<< std::endl;
478 
479  // ITCPlug2
480  double p2Z = 0.5*(plug2Z-plug2hZ+tileExtZ);
481  double hp2Z = 0.5*(tileExtZ-plug2Z+plug2hZ);
482  itcPlug2Bounds = new Trk::CylinderVolumeBounds(plug2R,
483  plug1R,
484  hp2Z);
485 
486  Amg::Vector3D itcP2Pos(0.,0.,p2Z);
487  Amg::Vector3D itcP2Neg(0.,0.,-p2Z);
488  Amg::Transform3D* itcP2PosTransform = new Amg::Transform3D(Amg::Translation3D(itcP2Pos));
489  Amg::Transform3D* itcP2NegTransform = new Amg::Transform3D(Amg::Translation3D(itcP2Neg));
490 
491  std::vector<size_t> p2lay(1,0);
492  std::vector<float> p2steps{float(plug2R), float(plug1R)};
493  Trk::BinUtility* p2BU = new Trk::BinUtility(p2steps, Trk::open, Trk::binR);
494  Trk::BinUtility* p2BUc = p2BU->clone();
495  const Trk::BinnedMaterial* plug2MatPos = new Trk::BinnedMaterial(barrelProperties.get(),p2BU,p2lay,matITC);
496  const Trk::BinnedMaterial* plug2MatNeg = new Trk::BinnedMaterial(barrelProperties.get(),p2BUc,p2lay,matITC);
497 
498  Trk::AlignableTrackingVolume* itcPlug2Pos = new Trk::AlignableTrackingVolume(itcP2PosTransform, align,
499  itcPlug2Bounds,
500  plug2MatPos,
501  15,
502  "Calo::Detectors::Tile::ITCPlug2Pos");
503 
504  Trk::AlignableTrackingVolume* itcPlug2Neg = new Trk::AlignableTrackingVolume(itcP2NegTransform, align,
505  itcPlug2Bounds->clone(),
506  plug2MatNeg,
507  15,
508  "Calo::Detectors::Tile::ITCPlug2Neg");
509 
510  //std::cout <<"ITC Plug2 ok:"<< std::endl;
511 
512  // Gap
513  float gapi = 0.5*(gapZ-gapBounds->halflengthZ()+tileExtZ);
514  double hgZ = 0.5*(tileExtZ-gapZ+gapBounds->halflengthZ());
515  delete gapBounds;
516  gapBounds = new Trk::CylinderVolumeBounds(tileBarrelBounds->innerRadius(),
517  plug2R,
518  hgZ);
519 
520  Amg::Vector3D gPos(0.,0.,gapi);
521  Amg::Vector3D gNeg(0.,0.,-gapi);
522  Amg::Transform3D* gapPosTransform = new Amg::Transform3D(Amg::Translation3D(gPos));
523  Amg::Transform3D* gapNegTransform = new Amg::Transform3D(Amg::Translation3D(gNeg));
524 
525  std::vector<size_t> glay(1,2);
526  std::vector<float> gsteps{float(gapi-gapBounds->halflengthZ()), float(gapi+gapBounds->halflengthZ())};
527  Trk::BinUtility* gp = new Trk::BinUtility(gsteps, Trk::open, Trk::binZ);
528  const Trk::BinnedMaterial* gpMat = new Trk::BinnedMaterial(barrelProperties.get(),gp,glay,matITC);
529 
530  Trk::AlignableTrackingVolume* gapPos = new Trk::AlignableTrackingVolume(gapPosTransform, align,
531  gapBounds,
532  gpMat,
533  17,
534  "Calo::Detectors::Tile::GapPos");
535 
536  std::vector<float> nsteps{float(-gapi-gapBounds->halflengthZ()), float(-gapi+gapBounds->halflengthZ())};
537  Trk::BinUtility* gn = new Trk::BinUtility(nsteps, Trk::open, Trk::binZ);
538  const Trk::BinnedMaterial* gnMat = new Trk::BinnedMaterial(barrelProperties.get(),gn,glay,matITC);
539 
540  Trk::AlignableTrackingVolume* gapNeg = new Trk::AlignableTrackingVolume(gapNegTransform, align,
541  gapBounds->clone(),
542  gnMat,
543  15,
544  "Calo::Detectors::Tile::GapNeg");
545 
546  // add buffer volumes and glue together gap sections
547  float p1i = itcPlug1Pos->center().z()-itcPlug1Bounds->halflengthZ();
548  float p2i = itcPlug2Pos->center().z()-itcPlug2Bounds->halflengthZ();
549  float gi = gapPos->center().z()-gapBounds->halflengthZ();
550  float zgBuff = 0.5*(p1i+gi);
551  float hgBuff = 0.5*(gi-p1i);
552  Amg::Vector3D gBuffPos(0.,0.,zgBuff);
553  Amg::Vector3D gBuffNeg(0.,0.,-zgBuff);
554  Amg::Transform3D* gBuffPosTransform = new Amg::Transform3D(Amg::Translation3D(gBuffPos));
555  Amg::Transform3D* gBuffNegTransform = new Amg::Transform3D(Amg::Translation3D(gBuffNeg));
556 
557  Trk::CylinderVolumeBounds* gapBuffBounds = new Trk::CylinderVolumeBounds(gapBounds->innerRadius(),
558  gapBounds->outerRadius(),
559  hgBuff);
560 
561 
562  Trk::TrackingVolume* gBufferPos = new Trk::TrackingVolume(gBuffPosTransform,
563  gapBuffBounds,
564  fingerProperties,
565  dummyLayers, dummyVolumes,
566  "Calo::GapVolumes::Tile::GapBufferPos");
567 
568 
569  Trk::TrackingVolume* gBufferNeg = new Trk::TrackingVolume(gBuffNegTransform,
570  gapBuffBounds->clone(),
571  fingerProperties,
572  dummyLayers, dummyVolumes,
573  "Calo::GapVolumes::Tile::GapBufferNeg");
574 
575  Trk::TrackingVolume* positiveGapSector = nullptr;
576  if (gBufferPos) {
577  std::vector<Trk::TrackingVolume*> volsPosGap;
578  volsPosGap.push_back(gBufferPos);
579  volsPosGap.push_back(gapPos);
580  positiveGapSector = m_trackingVolumeCreator->createContainerTrackingVolume
581  (volsPosGap,
582  tileMaterial,
583  "Calo::Container::PositiveGap");
584  }
585  Trk::TrackingVolume* negativeGapSector = nullptr;
586  if (gBufferNeg) {
587  std::vector<Trk::TrackingVolume*> volsNegGap;
588  volsNegGap.push_back(gapNeg);
589  volsNegGap.push_back(gBufferNeg);
590  negativeGapSector = m_trackingVolumeCreator->createContainerTrackingVolume
591  (volsNegGap,
592  tileMaterial,
593  "Calo::Container::NegativeGap");
594  }
595 
596  // plug2 sector
597  float z2Buff = 0.5*(p1i+p2i);
598  float h2Buff = 0.5*(p2i-p1i);
599  Amg::Vector3D p2BuffPos(0.,0.,z2Buff);
600  Amg::Vector3D p2BuffNeg(0.,0.,-z2Buff);
601  Amg::Transform3D* p2BuffPosTransform = new Amg::Transform3D(Amg::Translation3D(p2BuffPos));
602  Amg::Transform3D* p2BuffNegTransform = new Amg::Transform3D(Amg::Translation3D(p2BuffNeg));
603 
604  Trk::CylinderVolumeBounds* p2BuffBounds = new Trk::CylinderVolumeBounds(itcPlug2Bounds->innerRadius(),
605  itcPlug2Bounds->outerRadius(),
606  h2Buff);
607 
608 
609  Trk::TrackingVolume* p2BufferPos = new Trk::TrackingVolume(p2BuffPosTransform,
610  p2BuffBounds,
611  fingerProperties,
612  dummyLayers, dummyVolumes,
613  "Calo::GapVolumes::Tile::Plug2BufferPos");
614 
615 
616  Trk::TrackingVolume* p2BufferNeg = new Trk::TrackingVolume(p2BuffNegTransform,
617  p2BuffBounds->clone(),
618  fingerProperties,
619  dummyLayers, dummyVolumes,
620  "Calo::GapVolumes::Tile::Plug2BufferNeg");
621 
622  Trk::TrackingVolume* positiveP2Sector = nullptr;
623  if (p2BufferPos) {
624  std::vector<Trk::TrackingVolume*> volsPosP2;
625  volsPosP2.push_back(p2BufferPos);
626  volsPosP2.push_back(itcPlug2Pos);
627  positiveP2Sector = m_trackingVolumeCreator->createContainerTrackingVolume
628  (volsPosP2,
629  tileMaterial,
630  "Calo::Container::PositiveP2");
631  }
632  Trk::TrackingVolume* negativeP2Sector = nullptr;
633  if (itcPlug2Neg) {
634  std::vector<Trk::TrackingVolume*> volsNegP2;
635  volsNegP2.push_back(itcPlug2Neg);
636  volsNegP2.push_back(p2BufferNeg);
637  negativeP2Sector = m_trackingVolumeCreator->createContainerTrackingVolume
638  (volsNegP2,
639  tileMaterial,
640  "Calo::Container::NegativeP2");
641  }
642 
643  // glue ITC sector radially
644  Trk::TrackingVolume* positiveITCSector = nullptr;
645  if (positiveGapSector && positiveP2Sector) {
646  std::vector<Trk::TrackingVolume*> volsITCPos;
647  volsITCPos.push_back(positiveGapSector);
648  volsITCPos.push_back(positiveP2Sector);
649  volsITCPos.push_back(itcPlug1Pos);
650  positiveITCSector = m_trackingVolumeCreator->createContainerTrackingVolume
651  (volsITCPos,
652  tileMaterial,
653  "Calo::Container::ITCPos");
654  }
655  Trk::TrackingVolume* negativeITCSector = nullptr;
656  if (negativeGapSector && negativeP2Sector) {
657  std::vector<Trk::TrackingVolume*> volsITCNeg;
658  volsITCNeg.push_back(negativeGapSector);
659  volsITCNeg.push_back(negativeP2Sector);
660  volsITCNeg.push_back(itcPlug1Neg);
661  negativeITCSector = m_trackingVolumeCreator->createContainerTrackingVolume
662  (volsITCNeg,
663  tileMaterial,
664  "Calo::Container::ITCNeg");
665  }
666 
667  ATH_MSG_DEBUG( "Gap volumes (ITC sector) built " );
668 
669  // ------------------------------ BARREL SECTION COMPLETION --------------------------------------------------
670 
671  // the Finger Gap Volumes to be constructed
672  double rMin = tileBarrelBounds->innerRadius();
673  double rMax = tileBarrelBounds->outerRadius();
674 
675  double zFG = 0.5*(tileBarrelBounds->halflengthZ()+p1i);
676  double hZ = 0.5*(p1i-tileBarrelBounds->halflengthZ());
677  Trk::CylinderVolumeBounds* tileBarrelFingerGapBounds = new Trk::CylinderVolumeBounds(rMin,rMax,hZ);
678 
679  Amg::Vector3D pBFPos(0.,0.,zFG);
680  Amg::Vector3D pBFNeg(0.,0.,-zFG);
681  Amg::Transform3D* bfPosTransform = new Amg::Transform3D(Amg::Translation3D(pBFPos));
682  Amg::Transform3D* bfNegTransform = new Amg::Transform3D(Amg::Translation3D(pBFNeg));
683 
684  tileBarrelPositiveFingerGap = new Trk::TrackingVolume(bfPosTransform,
685  tileBarrelFingerGapBounds,
686  barrelFingerGapProperties,
687  dummyLayers, dummyVolumes,
688  "Calo::GapVolumes::Tile::BarrelPositiveFingerGap");
689 
690  tileBarrelNegativeFingerGap = new Trk::TrackingVolume(bfNegTransform,
691  tileBarrelFingerGapBounds->clone(),
692  barrelFingerGapProperties,
693  dummyLayers, dummyVolumes,
694  "Calo::GapVolumes::Tile::BarrelNegativeFingerGap");
695 
696 
697  // ------------------------------ ENDCAP SECTION COMPLETION --------------------------------------------------
698 
699  double zBE = tilePositiveExtendedBarrel->center().z()+tilePositiveExtendedBarrelBounds.halflengthZ();
700  zFG = 0.5*(tileZ + zBE);
701  hZ = 0.5*(tileZ - zBE);
702 
703  Trk::CylinderVolumeBounds* tilePositiveFingerGapBounds = new Trk::CylinderVolumeBounds(
704  tilePositiveExtendedBarrelBounds.innerRadius(),
705  tilePositiveExtendedBarrelBounds.outerRadius(),
706  hZ);
707 
708  Amg::Vector3D pEFPos(0.,0.,zFG);
709  Amg::Vector3D pEFNeg(0.,0.,-zFG);
710  Amg::Transform3D* efPosTransform = new Amg::Transform3D(Amg::Translation3D(pEFPos));
711  Amg::Transform3D* efNegTransform = new Amg::Transform3D(Amg::Translation3D(pEFNeg));
712 
713  tilePositiveFingerGap = new Trk::TrackingVolume(efPosTransform,
714  tilePositiveFingerGapBounds,
715  fingerGapProperties,
716  dummyLayers, dummyVolumes,
717  "Calo::GapVolumes::Tile::PositiveFingerGap");
718 
719  tileNegativeFingerGap = new Trk::TrackingVolume(efNegTransform,
720  tilePositiveFingerGapBounds->clone(),
721  fingerGapProperties,
722  dummyLayers, dummyVolumes,
723  "Calo::GapVolumes::Tile::NegativeFingerGap");
724 
725 
726  // set the color code for displaying
727  tileBarrel->registerColorCode( 4 );
728  tilePositiveExtendedBarrel->registerColorCode( 4 );
729  tileNegativeExtendedBarrel->registerColorCode( 4 );
730 
731  gapPos->registerColorCode( 4 );
732  gapNeg->registerColorCode( 4 );
733  itcPlug1Pos->registerColorCode( 4 );
734  itcPlug1Neg->registerColorCode( 4 );
735  itcPlug2Pos->registerColorCode( 4 );
736  itcPlug2Neg->registerColorCode( 4 );
737 
738  tileGirder->registerColorCode( 12 );
739 
740  // finalize Tile : glue locally and return 1 volume
741  ATH_MSG_DEBUG( "Gluing Tile volumes" );
742 
743  // glue tile volumes in z
744  std::vector<Trk::TrackingVolume*> tileVols;
745  tileVols.push_back(tileNegativeFingerGap);
746  tileVols.push_back(tileNegativeExtendedBarrel);
747  tileVols.push_back(negativeITCSector);
748  tileVols.push_back(tileBarrelNegativeFingerGap);
749  tileVols.push_back(tileBarrel);
750  tileVols.push_back(tileBarrelPositiveFingerGap);
751  tileVols.push_back(positiveITCSector);
752  tileVols.push_back(tilePositiveExtendedBarrel);
753  tileVols.push_back(tilePositiveFingerGap);
754  Trk::TrackingVolume* tileCombinedSector = m_trackingVolumeCreator->createContainerTrackingVolume
755  (tileVols,
756  tileMaterial,
757  "Calo::Container::Tile::InnerSector");
758 
759  // glue with combined girder
760  std::vector<Trk::TrackingVolume*> tileVolumes;
761  tileVolumes.push_back(tileCombinedSector);
762  tileVolumes.push_back(tileGirder);
763  Trk::TrackingVolume* tile = m_trackingVolumeCreator->createContainerTrackingVolume
764  (tileVolumes,
765  tileMaterial,
766  "Calo::Container::Tile::Combined");
767 
768  ATH_MSG_DEBUG( "Combined Tile built " );
769 
770  tileTrackingVolumes->push_back(tile); // [0]
771  tileTrackingVolumes->push_back(tilePositiveExtendedBarrel); // [1]
772 
773  if (msgLvl(MSG::INFO)) {
774  ATH_MSG_DEBUG( "Checking the existence of all Tracking Volumes:" );
775  ATH_MSG_DEBUG( " -> Tile::Barrel ");
776  printCheckResult(msg(MSG::DEBUG), tileBarrel);
777  ATH_MSG_DEBUG( " -> Tile::PositiveExtendedBarrel ");
778  printCheckResult(msg(MSG::DEBUG), tilePositiveExtendedBarrel);
779  ATH_MSG_DEBUG( " -> Tile::NegativeExtendedBarrel ");
780  printCheckResult(msg(MSG::DEBUG), tileNegativeExtendedBarrel);
781  ATH_MSG_DEBUG( " -> Tile::BarrelPositiveFingerGap ");
782  printCheckResult(msg(MSG::DEBUG), tileBarrelPositiveFingerGap);
783  ATH_MSG_DEBUG( " -> Tile::BarrelNegativeFingerGap ");
784  printCheckResult(msg(MSG::DEBUG), tileBarrelNegativeFingerGap);
785  ATH_MSG_DEBUG( " -> Tile::PositiveFingerGap ");
786  printCheckResult(msg(MSG::DEBUG), tilePositiveFingerGap);
787  ATH_MSG_DEBUG( " -> Tile::NegativeFingerGap ");
788  printCheckResult(msg(MSG::DEBUG), tileNegativeFingerGap);
789  ATH_MSG_DEBUG( " -> Tile::Girder ");
790  printCheckResult(msg(MSG::DEBUG), tileGirder);
791  } // end of detailed output
792 
793  throwIntoGarbage (std::move (barrelProperties));
794  throwIntoGarbage (std::move (extendedBarrelProperties));
795 
796  return tileTrackingVolumes;
797 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::vector<std::unique_ptr<Trk::Material> > m_garbage Tile::TileVolumeBuilder::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 100 of file TileVolumeBuilder.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_forceSymmetry

bool Tile::TileVolumeBuilder::m_forceSymmetry
private

forces volume symmetry between negative/positive part

Definition at line 97 of file TileVolumeBuilder.h.

◆ m_garbageMutex

std::mutex Tile::TileVolumeBuilder::m_garbageMutex
mutableprivate

Definition at line 99 of file TileVolumeBuilder.h.

◆ m_surfBuilder

ToolHandle<ICaloSurfaceBuilder> Tile::TileVolumeBuilder::m_surfBuilder
private

tool required for definition of active volumes

Definition at line 95 of file TileVolumeBuilder.h.

◆ m_tileBarrelEnvelope

double Tile::TileVolumeBuilder::m_tileBarrelEnvelope
private

envelope Cover of the Barrel

Definition at line 90 of file TileVolumeBuilder.h.

◆ m_tileBarrelLayersPerSampling

unsigned int Tile::TileVolumeBuilder::m_tileBarrelLayersPerSampling
private

if m_useCaloSurfBuilder == true, number of layers per dead material region or sampling

Definition at line 93 of file TileVolumeBuilder.h.

◆ m_tileMgr

const TileDetDescrManager* Tile::TileVolumeBuilder::m_tileMgr
private

Calo DetDescrMgr.

Definition at line 84 of file TileVolumeBuilder.h.

◆ m_tileMgrLocation

std::string Tile::TileVolumeBuilder::m_tileMgrLocation
private

Location of the CaloDetDescrMgr.

Definition at line 85 of file TileVolumeBuilder.h.

◆ m_trackingVolumeCreator

ToolHandle<Trk::ITrackingVolumeCreator> Tile::TileVolumeBuilder::m_trackingVolumeCreator
private

Second helper for volume creation.

Definition at line 88 of file TileVolumeBuilder.h.

◆ m_trackingVolumeHelper

ToolHandle<Trk::ITrackingVolumeHelper> Tile::TileVolumeBuilder::m_trackingVolumeHelper
private

Helper Tool to create TrackingVolumes.

Definition at line 87 of file TileVolumeBuilder.h.

◆ m_useCaloSurfBuilder

bool Tile::TileVolumeBuilder::m_useCaloSurfBuilder
private

if true use DetDescr based layering, if false use biequidistant layering

Definition at line 92 of file TileVolumeBuilder.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Tile::TileVolumeBuilder::m_tileMgrLocation
std::string m_tileMgrLocation
Location of the CaloDetDescrMgr.
Definition: TileVolumeBuilder.h:85
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Tile::TileVolumeBuilder::m_trackingVolumeCreator
ToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
Second helper for volume creation.
Definition: TileVolumeBuilder.h:88
Trk::binZ
@ binZ
Definition: BinningType.h:49
Tile::TileVolumeBuilder::m_tileBarrelLayersPerSampling
unsigned int m_tileBarrelLayersPerSampling
if m_useCaloSurfBuilder == true, number of layers per dead material region or sampling
Definition: TileVolumeBuilder.h:93
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
Tile::TileVolumeBuilder::throwIntoGarbage
void throwIntoGarbage(std::unique_ptr< Trk::Material > mat) const
Definition: TileVolumeBuilder.cxx:860
mat
GeoMaterial * mat
Definition: LArDetectorConstructionTBEC.cxx:55
Trk::BinnedMaterial
Definition: BinnedMaterial.h:38
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::Calo
@ Calo
Definition: GeometrySignature.h:28
Trk::TrackingVolume::registerColorCode
void registerColorCode(unsigned int icolor)
Register the color code.
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ReadCellNoiseFromCool.tile
tile
Definition: ReadCellNoiseFromCool.py:92
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TileDetDescrManager::getTreeTop
virtual PVConstLink getTreeTop(unsigned int i) const override
Definition: TileDetDescrManager.cxx:79
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
Tile::TileVolumeBuilder::m_garbageMutex
std::mutex m_garbageMutex
Definition: TileVolumeBuilder.h:99
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
beamspotman.steps
int steps
Definition: beamspotman.py:505
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
TileDetDescrManager::getNumTreeTops
virtual unsigned int getNumTreeTops() const override
Definition: TileDetDescrManager.cxx:74
beamspotman.n
n
Definition: beamspotman.py:731
Tile::TileVolumeBuilder::m_tileBarrelEnvelope
double m_tileBarrelEnvelope
envelope Cover of the Barrel
Definition: TileVolumeBuilder.h:90
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
Tile::TileVolumeBuilder::m_trackingVolumeHelper
ToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
Helper Tool to create TrackingVolumes.
Definition: TileVolumeBuilder.h:87
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:86
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
checkCorrelInHIST.gi
dictionary gi
Definition: checkCorrelInHIST.py:404
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Tile::TileVolumeBuilder::m_useCaloSurfBuilder
bool m_useCaloSurfBuilder
if true use DetDescr based layering, if false use biequidistant layering
Definition: TileVolumeBuilder.h:92
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
Trk::BinUtility
Definition: BinUtility.h:39
grepfile.ic
int ic
Definition: grepfile.py:33
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
Tile::TileVolumeBuilder::m_surfBuilder
ToolHandle< ICaloSurfaceBuilder > m_surfBuilder
tool required for definition of active volumes
Definition: TileVolumeBuilder.h:95
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::open
@ open
Definition: BinningType.h:40
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
Trk::binR
@ binR
Definition: BinningType.h:50
Trk::GeoShapeConverter::convert
static std::unique_ptr< CylinderVolumeBounds > convert(const GeoTubs *gtub)
Convert a tubs.
Definition: GeoShapeConverter.cxx:57
python.CaloAddPedShiftConfig.default
default
Definition: CaloAddPedShiftConfig.py:43
a
TList * a
Definition: liststreamerinfos.cxx:10
h
Trk::CylinderVolumeBounds::innerRadius
double innerRadius() const
This method returns the inner radius.
Definition: CylinderVolumeBounds.h:187
DeMoScan.first
bool first
Definition: DeMoScan.py:536
DEBUG
#define DEBUG
Definition: page_access.h:11
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
Trk::BinUtility::clone
BinUtility * clone() const
Implizit Constructor.
Definition: BinUtility.h:130
python.changerun.pv
pv
Definition: changerun.py:81
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
Tile::TileVolumeBuilder::printCheckResult
static void printCheckResult(MsgStream &log, const Trk::TrackingVolume *vol)
Definition: TileVolumeBuilder.cxx:799
LVL1::gFEXPos
Definition: gFexPos.h:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Trk::Material
Definition: Material.h:116
Trk::BinnedArray
Definition: BinnedArray.h:38
Trk::TrackingVolume
Definition: TrackingVolume.h:121
Trk::CylinderVolumeBounds::clone
CylinderVolumeBounds * clone() const override
Virtual constructor.
Definition: CylinderVolumeBounds.h:171
Material
@ Material
Definition: MaterialTypes.h:8
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Tile::TileVolumeBuilder::m_tileMgr
const TileDetDescrManager * m_tileMgr
Calo DetDescrMgr.
Definition: TileVolumeBuilder.h:84
Tile::TileVolumeBuilder::m_forceSymmetry
bool m_forceSymmetry
forces volume symmetry between negative/positive part
Definition: TileVolumeBuilder.h:97
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
Tile::TileVolumeBuilder::printChildren
void printChildren(const GeoPVConstLink &pv, int igen, const Amg::Transform3D &trIn) const
Definition: TileVolumeBuilder.cxx:817
fitman.k
k
Definition: fitman.py:528
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Trk::AlignableTrackingVolume
Definition: AlignableTrackingVolume.h:36
Generated on Sat Apr 12 2025 22:08:03 for ATLAS Offline Software by   doxygen 1.8.18