Trk::TrackingGeometrySvc Class Reference

This service builds and registers the TrackingGeometry in the detector store. More...

#include <TrackingGeometrySvc.h>

Inheritance diagram for Trk::TrackingGeometrySvc:

Collaboration diagram for Trk::TrackingGeometrySvc:

Public Member Functions
virtual StatusCode	initialize () override
	Initialize Service.
virtual StatusCode	finalize () override
	Finalize Service.
virtual void	tagInfoUpdated () override final
StatusCode	trackingGeometryInit (bool needsInit=true)
	Create the geometry.
virtual const Trk::TrackingGeometry *	trackingGeometry () const override
	Provide the TrackingGeometry.
virtual const std::string &	trackingGeometryName () const override
	TrackingGeometrySvc (const std::string &name, ISvcLocator *svc)
	Standard Destructor.
virtual	~TrackingGeometrySvc ()
	Destructor.

Private Member Functions
void	trackingGeometryNotSet () const

Private Attributes
ToolHandle< Trk::IGeometryBuilder >	m_trackingGeometryBuilder {this, "GeometryBuilder", ""}
	the actual building tool
const Trk::TrackingGeometry *	m_trackingGeometry {nullptr}
	the cached TrackingGeometry
Gaudi::Property< std::string >	m_trackingGeometryName {this, "TrackingGeometryName", "AtlasTrackingGeometry"}
	the name of the TrackingGeometry
ToolHandleArray< Trk::IGeometryProcessor >	m_geometryProcessors
Gaudi::Property< bool >	m_rerunOnCallback {this, "RerunOnCallback", false}
	< processors to help
Gaudi::Property< bool >	m_buildGeometryFromTagInfo {this, "BuildGeometryFromTagInfo", true}

Friends
class	SvcFactory< TrackingGeometrySvc >
	Standard Constructor.

Detailed Description

This service builds and registers the TrackingGeometry in the detector store.

It is called by an ordered callback after GeoModel was created.

Author

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

Definition at line 45 of file TrackingGeometrySvc.h.

Constructor & Destructor Documentation

TrackingGeometrySvc()

Trk::TrackingGeometrySvc::TrackingGeometrySvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Destructor.

Constructor.

Definition at line 29 of file TrackingGeometrySvc.cxx.

  : base_class(name, svc)
  , m_geometryProcessors(this)
{
  // geometry processors to validation / distort the TrackingGeometry ------------
  declareProperty("GeometryProcessors", m_geometryProcessors);
}

~TrackingGeometrySvc()

Trk::TrackingGeometrySvc::~TrackingGeometrySvc ( )

virtualdefault

Destructor.

Member Function Documentation

finalize()

StatusCode Trk::TrackingGeometrySvc::finalize ( )

overridevirtual

Finalize Service.

Definition at line 186 of file TrackingGeometrySvc.cxx.

{
#ifdef TRKDETDESCR_MEMUSAGE
  ATH_MSG_INFO("[ memory usage ] Change in memory usage -------------------------------- ");
  ATH_MSG_INFO("[ memory usage ]    Virtual memory change (vsize) : " << m_changeVsize);
  ATH_MSG_INFO("[ memory usage ]    Real memory change (rss)      : " << m_changeRss);
  ATH_MSG_INFO("[ memory usage ] ---------------------------------------------------------");
#endif
  ATH_MSG_INFO("finalize() successful.");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode Trk::TrackingGeometrySvc::initialize ( )

overridevirtual

Initialize Service.

Definition at line 42 of file TrackingGeometrySvc.cxx.

{
 
  ATH_MSG_WARNING(
    "!!! Initialization of TrackingGeometrySvc !!! The Service it to be "
    "deprecated in favour of the relevant Condition Algorithm. !!!");
  m_autoRetrieveTools = false;
  m_checkToolDeps = false;
 
  if (m_geometryProcessors.retrieve().isFailure()) {
    ATH_MSG_FATAL("Could not retrieve " << m_geometryProcessors);
    return StatusCode::FAILURE;
  }
 
  if (m_buildGeometryFromTagInfo) {
    ATH_MSG_INFO("Building Geometry from TagInfo");
    // register a callback on TagInfo updates
    ServiceHandle<ITagInfoMgr> tagInfoMgr("TagInfoMgr", name());
    ATH_CHECK(tagInfoMgr.retrieve());
    tagInfoMgr->addListener(this);
  } else {
    ATH_MSG_INFO("Building Geometry at initialisation time.");
    // build with no dependency on COOL
    if (trackingGeometryInit(false).isFailure()) {
      ATH_MSG_FATAL("Unable to build the TrackingGeometry!");
      return StatusCode::FAILURE;
    }
  }
  ATH_MSG_INFO("initialize() successful! ");
  return StatusCode::SUCCESS;
}

tagInfoUpdated()

void Trk::TrackingGeometrySvc::tagInfoUpdated ( )

finaloverridevirtual

Implements ITagInfoMgr::Listener.

Definition at line 75 of file TrackingGeometrySvc.cxx.

{
  ATH_MSG_INFO("tagInfoUpdated() callback trigerred");
  trackingGeometryInit().ignore();
}

trackingGeometry()

const Trk::TrackingGeometry * Trk::TrackingGeometrySvc::trackingGeometry ( ) const

inlineoverridevirtual

Provide the TrackingGeometry.

Returns the name of the TrackingGeometry built with this Svc

Definition at line 99 of file TrackingGeometrySvc.h.

{  if (!m_trackingGeometry) { trackingGeometryNotSet(); }
   return m_trackingGeometry; }

trackingGeometryInit()

StatusCode Trk::TrackingGeometrySvc::trackingGeometryInit

(

bool

needsInit = true

)

Create the geometry.

Definition at line 82 of file TrackingGeometrySvc.cxx.

{
  ATH_MSG_INFO("Trk::TrackingGeometrySvc::trackingGeometryInit");
 
  SmartIF<StoreGateSvc> detStore{service("DetectorStore")};
  ATH_CHECK( detStore.isValid() );
 
  // Retrieve the tracking geometry builder tool
  // ----------------------------------------------------
  if (!m_trackingGeometryBuilder.empty() && m_trackingGeometryBuilder.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool '" << m_trackingGeometryBuilder << "'. Aborting.");
    return StatusCode::FAILURE;
  } else if (m_trackingGeometryBuilder.empty()) {
    ATH_MSG_FATAL("TrackingGeometrySvc " << name()
                                         << " not properly configured. No GeometryBuilder defined. Aborting.");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG("Retrieved tool " << m_trackingGeometryBuilder);
  }
 
  // nothing to do in this case since rerun is switched off
  if (detStore->contains<Trk::TrackingGeometry>(m_trackingGeometryName) && !m_rerunOnCallback) {
    return StatusCode::SUCCESS;
  }
 
  // only build if the callback string was true
  // (MN: I set this to alwaus true if called on TagInfo update)
  if (needsInit) {
    ATH_MSG_INFO("trackingGeometryInit - initialize on TagInfoMgr callback");
    // cleanup the geometry if you have one
    // (will delete what is in detector store, because new one will overwrite old one)
    m_trackingGeometry = nullptr;
 
#ifdef TRKDETDESCR_MEMUSAGE
    // memory monitoring
    ATH_MSG_INFO("[ memory usage ] Start to monitor memory usage of PID: " << getpid());
 
    m_memoryLogger.refresh(getpid());
    ATH_MSG_INFO(m_memoryLogger);
    // record the difference
    m_changeVsize = (-1.) * m_memoryLogger.vmSize();
    m_changeRss = (-1.) * m_memoryLogger.vmRss();
#endif
 
    // build the TrackingGeometry from the builder
    m_trackingGeometry = m_trackingGeometryBuilder->trackingGeometry().release();
 
#ifdef TRKDETDESCR_MEMUSAGE
    ATH_MSG_INFO("[ memory usage ] TrackingGeometry retrieved: ");
    m_memoryLogger.refresh(getpid());
    ATH_MSG_INFO(m_memoryLogger);
#endif
 
    // cast constness away for StoreGate
    Trk::TrackingGeometry* atlasTrackingGeometry = const_cast<Trk::TrackingGeometry*>(m_trackingGeometry);
 
    // check if a second call back has occured
    if (detStore->contains<Trk::TrackingGeometry>(m_trackingGeometryName)) {
      ATH_MSG_VERBOSE("New Callback evoked remove of existing object!");
      // you need to retrieve the object first to remove it
      const Trk::TrackingGeometry* oldTrackingGeometry = nullptr;
      if (detStore->retrieve(oldTrackingGeometry, m_trackingGeometryName).isFailure())
        ATH_MSG_WARNING("Callback evoked remove of '" << m_trackingGeometryName << "'. But retrieve did not succeed! ");
      if (oldTrackingGeometry && detStore->remove<Trk::TrackingGeometry>(oldTrackingGeometry).isFailure())
        ATH_MSG_WARNING("Callback evoked remove of '" << m_trackingGeometryName << "'. But it did not succeed!");
      // delete is safe
      delete oldTrackingGeometry;
    }
 
    // loop over the recursive geometry processors
    ToolHandleArray<Trk::IGeometryProcessor>::iterator gpIter = m_geometryProcessors.begin();
    ToolHandleArray<Trk::IGeometryProcessor>::iterator gpIterE = m_geometryProcessors.end();
    for (; gpIter != gpIterE; ++gpIter) {
      if ((*gpIter)->process(*atlasTrackingGeometry).isFailure()) {
        ATH_MSG_FATAL("Processing of TrackingGeometry did not succeed. Abort.");
        return StatusCode::FAILURE;
      } else {
        ATH_MSG_VERBOSE("Successfully processed the TrackingGeometry with " << (*gpIter));
#ifdef TRKDETDESCR_MEMUSAGE
        ATH_MSG_INFO("[ memory usage ] After processing with " << (*gpIter));
        m_memoryLogger.refresh(getpid());
        ATH_MSG_INFO(m_memoryLogger);
#endif
      }
    }
    // record the resulting TrackingGeometry
    if (detStore->record(atlasTrackingGeometry, m_trackingGeometryName, false).isFailure()) {
      ATH_MSG_WARNING("Couldn't write TrackingGeometry to DetectorStore.");
    } else {
      ATH_MSG_DEBUG("initialize() successful: TrackingGeometry '" << m_trackingGeometryName
                                                                  << "' built and written to DetectorStore.");
    }
  }
  return StatusCode::SUCCESS;
}

trackingGeometryName()

const std::string & Trk::TrackingGeometrySvc::trackingGeometryName ( ) const

inlineoverridevirtual

Definition at line 103 of file TrackingGeometrySvc.h.

  { return m_trackingGeometryName; }

trackingGeometryNotSet()

void Trk::TrackingGeometrySvc::trackingGeometryNotSet ( ) const

private

Definition at line 179 of file TrackingGeometrySvc.cxx.

{
  ATH_MSG_WARNING("TrackingGeometry not set  ptr=" << static_cast<const void*>(m_trackingGeometry));
}

Friends And Related Symbol Documentation

SvcFactory< TrackingGeometrySvc >

friend class SvcFactory< TrackingGeometrySvc >

friend

Standard Constructor.

Definition at line 63 of file TrackingGeometrySvc.h.

Member Data Documentation

m_buildGeometryFromTagInfo

Gaudi::Property<bool> Trk::TrackingGeometrySvc::m_buildGeometryFromTagInfo {this, "BuildGeometryFromTagInfo", true}

private

Definition at line 95 of file TrackingGeometrySvc.h.

{this, "BuildGeometryFromTagInfo", true};

m_geometryProcessors

ToolHandleArray<Trk::IGeometryProcessor> Trk::TrackingGeometrySvc::m_geometryProcessors

private

Definition at line 84 of file TrackingGeometrySvc.h.

m_rerunOnCallback

Gaudi::Property<bool> Trk::TrackingGeometrySvc::m_rerunOnCallback {this, "RerunOnCallback", false}

private

< processors to help

enables the callback

Definition at line 93 of file TrackingGeometrySvc.h.

{this, "RerunOnCallback", false};

m_trackingGeometry

const Trk::TrackingGeometry* Trk::TrackingGeometrySvc::m_trackingGeometry {nullptr}

mutableprivate

the cached TrackingGeometry

Definition at line 79 of file TrackingGeometrySvc.h.

{nullptr};

m_trackingGeometryBuilder

ToolHandle<Trk::IGeometryBuilder> Trk::TrackingGeometrySvc::m_trackingGeometryBuilder {this, "GeometryBuilder", ""}

private

the actual building tool

Definition at line 77 of file TrackingGeometrySvc.h.

{this, "GeometryBuilder", ""};

m_trackingGeometryName

Gaudi::Property<std::string> Trk::TrackingGeometrySvc::m_trackingGeometryName {this, "TrackingGeometryName", "AtlasTrackingGeometry"}

private

the name of the TrackingGeometry

Definition at line 82 of file TrackingGeometrySvc.h.

{this, "TrackingGeometryName", "AtlasTrackingGeometry"};

---

The documentation for this class was generated from the following files:

• TrackingGeometrySvc.h
• TrackingGeometrySvc.cxx