ATLAS Offline Software
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 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 798 of file TileVolumeBuilder.cxx.

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

◆ printChildren()

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

Definition at line 816 of file TileVolumeBuilder.cxx.

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

◆ printInfo()

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

Definition at line 806 of file TileVolumeBuilder.cxx.

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

◆ 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 859 of file TileVolumeBuilder.cxx.

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

◆ trackingVolumes()

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

TrackingVolumeBuilder interface method - returns vector of Volumes.

Implements Trk::ICaloTrackingVolumeBuilder.

Definition at line 129 of file TileVolumeBuilder.cxx.

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

◆ 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 99 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 96 of file TileVolumeBuilder.h.

◆ m_garbageMutex

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

Definition at line 98 of file TileVolumeBuilder.h.

◆ m_surfBuilder

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

tool required for definition of active volumes

Definition at line 94 of file TileVolumeBuilder.h.

◆ m_tileBarrelEnvelope

double Tile::TileVolumeBuilder::m_tileBarrelEnvelope
private

envelope Cover of the Barrel

Definition at line 89 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 92 of file TileVolumeBuilder.h.

◆ m_tileMgr

const TileDetDescrManager* Tile::TileVolumeBuilder::m_tileMgr
private

Calo DetDescrMgr.

Definition at line 83 of file TileVolumeBuilder.h.

◆ m_tileMgrLocation

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

Location of the CaloDetDescrMgr.

Definition at line 84 of file TileVolumeBuilder.h.

◆ m_trackingVolumeCreator

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

Second helper for volume creation.

Definition at line 87 of file TileVolumeBuilder.h.

◆ m_trackingVolumeHelper

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

Helper Tool to create TrackingVolumes.

Definition at line 86 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 91 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:84
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:87
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:92
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:859
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:98
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:89
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:86
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:91
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:94
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
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:623
Tile::TileVolumeBuilder::printCheckResult
static void printCheckResult(MsgStream &log, const Trk::TrackingVolume *vol)
Definition: TileVolumeBuilder.cxx:798
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
python.CaloScaleNoiseConfig.default
default
Definition: CaloScaleNoiseConfig.py:79
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
readCCLHist.float
float
Definition: readCCLHist.py:83
Tile::TileVolumeBuilder::m_tileMgr
const TileDetDescrManager * m_tileMgr
Calo DetDescrMgr.
Definition: TileVolumeBuilder.h:83
Tile::TileVolumeBuilder::m_forceSymmetry
bool m_forceSymmetry
forces volume symmetry between negative/positive part
Definition: TileVolumeBuilder.h:96
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:816
fitman.k
k
Definition: fitman.py:528
Trk::AlignableTrackingVolume
Definition: AlignableTrackingVolume.h:36
Generated on Sun Dec 22 2024 22:09:02 for ATLAS Offline Software by   doxygen 1.8.18