DetDescrDBEnvelopeSvc Class Reference

#include <DetDescrDBEnvelopeSvc.h>

Inheritance diagram for DetDescrDBEnvelopeSvc:

Collaboration diagram for DetDescrDBEnvelopeSvc:

Public Member Functions
	DetDescrDBEnvelopeSvc (const std::string &name, ISvcLocator *svc)
	public AthService constructor
	~DetDescrDBEnvelopeSvc ()
	Destructor.
virtual StatusCode	initialize () override
	AthService initialize method.
virtual const RZPairVector &	getRZBoundary (AtlasDetDescr::AtlasRegion region) const override
	return a vector of (r,z) pairs, defining the respective envelope
virtual const RZPairVector &	getRPositiveZBoundary (AtlasDetDescr::AtlasRegion region) const override
	return a vector of (r,z) pairs, defining the envelope on the z>0 region

Private Member Functions
StatusCode	retrieveRZBoundaryOptionalFallback (const std::string &dbNode, const FallbackDoubleVector &r, const FallbackDoubleVector &z, RZPairVector &rzVec)
	retrieve and store the (r,z) values locally for the given DB node.
StatusCode	retrieveRZBoundary (const std::string &node, RZPairVector &rzVec)
	retrieve and store the (r,z) values locally for the given DB node
StatusCode	fallbackRZBoundary (const FallbackDoubleVector &r, const FallbackDoubleVector &z, RZPairVector &rzVec)
	use the fallback approach (python arguments) to set the (r,z) values
bool	enableFallback ()
	enable fallback solution:

Private Attributes
ServiceHandle< IRDBAccessSvc >	m_dbAccess {this, "RDBAccessSvc", "RDBAccessSvc"}
	the DetectorDescription database access method
ServiceHandle< IGeoModelSvc >	m_geoModelSvc {this, "GeoModelSvc", "GeoModelSvc"}
	ATLAS GeoModel.
std::string	m_atlasNode {"ATLAS"}
	main DDDB node for the ATLAS detector
std::string	m_atlasVersionTag {"AUTO"}
std::array< StringProperty, AtlasDetDescr::fNumAtlasRegions >	m_node
	the names of the DB nodes for the respective AtlasRegion
RZPairVector	m_rz [AtlasDetDescr::fNumAtlasRegions] {}
	internal (r,z) representation, one RZPairVector for each AtlasRegion
RZPairVector	m_rposz [AtlasDetDescr::fNumAtlasRegions] {}
	internal (r,z) representation for the positive z-side only, one RZPairVector for each AtlasRegion
Gaudi::Property< bool >	m_allowFallback {this, "EnableFallback", false}
	fallback solution, in case something goes wrong with the DB
bool	m_doFallback {false}
std::array< DoubleArrayProperty, AtlasDetDescr::fNumAtlasRegions >	m_fallbackR
std::array< DoubleArrayProperty, AtlasDetDescr::fNumAtlasRegions >	m_fallbackZ

Detailed Description

Definition at line 34 of file DetDescrDBEnvelopeSvc.h.

Constructor & Destructor Documentation

DetDescrDBEnvelopeSvc()

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

public AthService constructor

Constructor.

Definition at line 26 of file DetDescrDBEnvelopeSvc.cxx.

                                                                                    :
  base_class(name,svc)
{
}

~DetDescrDBEnvelopeSvc()

DetDescrDBEnvelopeSvc::~DetDescrDBEnvelopeSvc ( )

default

Destructor.

Member Function Documentation

enableFallback()

bool DetDescrDBEnvelopeSvc::enableFallback ( )

private

enable fallback solution:

enable fallback solution (if allowed)

Returns

true if fallback mode is allowed, false if no fallback allowed

Definition at line 34 of file DetDescrDBEnvelopeSvc.cxx.

{
  // fallback solution is already enabled
  if (m_doFallback) return true;
 
  // fallback solution not enabled yet
  if (m_allowFallback) {
    ATH_MSG_INFO("Unable to retrieve envelope definitions from DDDB. Enabling Python-based fallback definitions.");
    m_doFallback=true;
  } else {
    ATH_MSG_ERROR("Unable to retrieve envelope definitions from DDDB and Python-based fallback definitions are disabled.");
    m_doFallback = false;
  }
 
  return m_doFallback;
}

fallbackRZBoundary()

StatusCode DetDescrDBEnvelopeSvc::fallbackRZBoundary ( const FallbackDoubleVector & r, const FallbackDoubleVector & z, RZPairVector & rzVec )

private

use the fallback approach (python arguments) to set the (r,z) values

retrieve and store the (r,z) values locally for the given DB node

Definition at line 223 of file DetDescrDBEnvelopeSvc.cxx.

{
  unsigned short len = r.size();
 
  // r and z vectors must have same length
  if ( len != z.size() ) {
    ATH_MSG_ERROR("Unable to construct fallback envelope definition in (r,z) space, as the provided r and z vectors have different length");
    rzVec.clear();
    return StatusCode::FAILURE;
  }
 
  // loop over the given pairs of (r,z) values
  for ( unsigned short pos=0; pos<len; ++pos) {
 
    // read-in (r,z) duplet
    double curR = r[pos];
    double curZ = z[pos];
    // store (r,z) duplet locally
    rzVec.emplace_back(curR, curZ );
  }
 
  return StatusCode::SUCCESS;
}

getRPositiveZBoundary()

virtual const RZPairVector & DetDescrDBEnvelopeSvc::getRPositiveZBoundary ( AtlasDetDescr::AtlasRegion region ) const

inlineoverridevirtual

return a vector of (r,z) pairs, defining the envelope on the z>0 region

Definition at line 50 of file DetDescrDBEnvelopeSvc.h.

{ return m_rposz[region]; }

getRZBoundary()

virtual const RZPairVector & DetDescrDBEnvelopeSvc::getRZBoundary ( AtlasDetDescr::AtlasRegion region ) const

inlineoverridevirtual

return a vector of (r,z) pairs, defining the respective envelope

Definition at line 47 of file DetDescrDBEnvelopeSvc.h.

{ return m_rz[region]; }

initialize()

StatusCode DetDescrDBEnvelopeSvc::initialize ( )

overridevirtual

AthService initialize method.

Athena AthService initialize hook.

Definition at line 52 of file DetDescrDBEnvelopeSvc.cxx.

{
  ATH_MSG_INFO("Initializing ...");
 
  // retrieve DataBase access service
  ServiceHandle<IGeoDbTagSvc> geoDbTag("GeoDbTagSvc",name());
  ATH_CHECK(geoDbTag.retrieve());
 
  m_dbAccess.setName(geoDbTag->getParamSvcName());
  if ( m_dbAccess.retrieve().isFailure()) {
    ATH_MSG_ERROR("Could not locate RDBAccessSvc");
    if ( !enableFallback()) return StatusCode::FAILURE;
  }
 
  // retrieve the GeoModelSvc
  if ( !m_doFallback && (m_geoModelSvc.retrieve().isFailure()) ) {
    ATH_MSG_ERROR("Could not locate GeoModelSvc");
    if ( !enableFallback()) return StatusCode::FAILURE;
  }
 
 
  // (#) use the DB to retrieve the RZ values
  if ( !m_doFallback) {
    // geo model tag
    m_atlasVersionTag = m_geoModelSvc->atlasVersion();
    if( m_atlasVersionTag == "AUTO") m_atlasVersionTag = "ATLAS-00";
 
    // cache the volume definitions locally
    for ( int region = AtlasDetDescr::fFirstAtlasRegion; region < AtlasDetDescr::fNumAtlasRegions; region++) {
      StatusCode sc = retrieveRZBoundaryOptionalFallback( m_node[region].value(),
                                                          m_fallbackR[region].value(),
                                                          m_fallbackZ[region].value(),
                                                          m_rposz[region] );
 
      if (sc.isFailure()) {
        ATH_MSG_ERROR("Unable to retrieve subdetector envelope for detector region '" << 
                      AtlasDetDescr::AtlasRegionHelper::getName(region) << "'");
        return StatusCode::FAILURE;
      }
    }
 
  }
 
  // (#) or use the fallback solution right away
  else {
    // cache the volume definitions locally
    for ( int region = AtlasDetDescr::fFirstAtlasRegion; region < AtlasDetDescr::fNumAtlasRegions; region++) {
      StatusCode sc = fallbackRZBoundary( m_fallbackR[region].value(), m_fallbackZ[region].value(), m_rposz[region] );
 
      if (sc.isFailure()) {
        ATH_MSG_ERROR("Unable to retrieve sub-detector envelope in (r,z)-space for detector region '" <<
                      AtlasDetDescr::AtlasRegionHelper::getName(region) << "'");
        return StatusCode::FAILURE;
      }
    }
  }
 
  // mirror the RZPairs provided in m_rposz to describe all corner points
  // in (r,z) space for each envelope volume
  for ( int region = AtlasDetDescr::fFirstAtlasRegion; region < AtlasDetDescr::fNumAtlasRegions; region++) {
    ATH_MSG_VERBOSE( "Envelope: positive-z region=" << region);
    mirrorRZ( m_rposz[region], m_rz[region] );
  }
 
  // debugging output:
  if (msgLvl(MSG::VERBOSE)) {
    for ( int region = AtlasDetDescr::fFirstAtlasRegion; region < AtlasDetDescr::fNumAtlasRegions; region++) {
      int numEntries = m_rz[region].size();
      ATH_MSG_VERBOSE( "Envelope: complete region=" << region);
      for ( int num = 0; num<numEntries; num++) {
        ATH_MSG_VERBOSE("   pos=" << num << " r=" << m_rz[region][num].first << " z="<< m_rz[region][num].second);
      }
    }
  }
 
  ATH_MSG_INFO("Initialize successful.");
 
  return StatusCode::SUCCESS;
}

retrieveRZBoundary()

StatusCode DetDescrDBEnvelopeSvc::retrieveRZBoundary ( const std::string & node, RZPairVector & rzVec )

private

retrieve and store the (r,z) values locally for the given DB node

@TODO: implement positioning, see: http://alxr.usatlas.bnl.gov/lxr/source/atlas/AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory.cxx?v=head#054 const IRDBRecordset *DBPosition = m_dbAccess->getRecordset( m_dbPositionNode, m_atlasVersionTag, m_atlasNode );

Definition at line 165 of file DetDescrDBEnvelopeSvc.cxx.

{
  // clear the output RZPairVector
  rzVec.clear();
 
  // @TODO: implement checks and do output with the actual child tags taken
  // some output about the used tags
  //const std::string &detVersionTag = m_dbAccess->getChildTag( detNode /* child node */,
  //                                                            m_atlasVersionTag /* parent tag */,
  //                                                            m_atlasNode /* parent node */,
  //                                                            false /*don't fetch data*/ );
  //const std::string &parentVersionTag = m_dbAccess->getChildTag( parentNode,
  //                                                               detVersionTag,
  //                                                               detNode,
  //                                                               false);
  //const std::string &envVersionTag = m_dbAccess->getChildTag( envNode,
  //                                                            parentVersionTag,
  //                                                            parentNode,
  //                                                            false );
  //ATH_MSG_INFO( "DDDB tags used for envelope construction: "
  //              << m_atlasVersionTag << " / " << detVersionTag << " / "
  //              << parentVersionTag << " / " << envVersionTag );
 
  // get a handle on the DB entries (don't delete, handeled internally)
  IRDBRecordset_ptr envelopeRec = m_dbAccess->getRecordsetPtr( node,
                                                               m_atlasVersionTag,
                                                               m_atlasNode );

 
 
  // entries in the database table
  size_t numEntries = envelopeRec ? envelopeRec->size() : 0;
  if ( !numEntries) {
    ATH_MSG_INFO("No entries for table '" << node << "' in Detector Description Database (DDDB). Maybe you are using Python-based envelope definitions...");
    return StatusCode::RECOVERABLE;
  }
 
  // retrieve data from the DB 
  IRDBRecordset::const_iterator recIt  = envelopeRec->begin();
  IRDBRecordset::const_iterator recEnd = envelopeRec->end();
  for ( ; recIt!=recEnd; ++recIt) {
 
    // read-in (r,z) duplet
    double curR = (*recIt)->getDouble("R") * CLHEP::mm;
    double curZ = (*recIt)->getDouble("Z") * CLHEP::mm;
    // store (r,z) duplet locally
    rzVec.emplace_back(curR, curZ );
  }
 
  return StatusCode::SUCCESS;
}

retrieveRZBoundaryOptionalFallback()

StatusCode DetDescrDBEnvelopeSvc::retrieveRZBoundaryOptionalFallback ( const std::string & dbNode, const FallbackDoubleVector & r, const FallbackDoubleVector & z, RZPairVector & rzVec )

private

retrieve and store the (r,z) values locally for the given DB node.

if there are problems with retrieving this from DDDB, try the fallback approach if allowed

Definition at line 135 of file DetDescrDBEnvelopeSvc.cxx.

{
  // clear the output RZPairVector
  rzVec.clear();
 
  // try the DB approach to retrieve the (r,z) values
  StatusCode sc = retrieveRZBoundary(dbNode, rzVec);
 
  // if empty vector returned -> unsuccessfully read DDDB
  if (sc.isFailure()) {
    ATH_MSG_DEBUG("Will try reading Python-based envelope definition for '" << dbNode << "'.");
 
    // try fallback approach
    sc = enableFallback() ? fallbackRZBoundary(r, z, rzVec) : StatusCode::FAILURE;
    if (sc.isFailure()) {
      ATH_MSG_WARNING("Could not create envelope volume for '" << dbNode << "'.");
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_INFO("Sucessfully read Python-based envelope definition for '" << dbNode << "'.");
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_allowFallback

Gaudi::Property<bool> DetDescrDBEnvelopeSvc::m_allowFallback {this, "EnableFallback", false}

private

fallback solution, in case something goes wrong with the DB

Definition at line 100 of file DetDescrDBEnvelopeSvc.h.

{this, "EnableFallback", false};

m_atlasNode

std::string DetDescrDBEnvelopeSvc::m_atlasNode {"ATLAS"}

private

main DDDB node for the ATLAS detector

Definition at line 80 of file DetDescrDBEnvelopeSvc.h.

{"ATLAS"};

m_atlasVersionTag

std::string DetDescrDBEnvelopeSvc::m_atlasVersionTag {"AUTO"}

private

Definition at line 81 of file DetDescrDBEnvelopeSvc.h.

{"AUTO"};

m_dbAccess

ServiceHandle<IRDBAccessSvc> DetDescrDBEnvelopeSvc::m_dbAccess {this, "RDBAccessSvc", "RDBAccessSvc"}

private

the DetectorDescription database access method

Definition at line 74 of file DetDescrDBEnvelopeSvc.h.

{this, "RDBAccessSvc", "RDBAccessSvc"};

m_doFallback

bool DetDescrDBEnvelopeSvc::m_doFallback {false}

private

Definition at line 101 of file DetDescrDBEnvelopeSvc.h.

{false};

m_fallbackR

std::array<DoubleArrayProperty,AtlasDetDescr::fNumAtlasRegions> DetDescrDBEnvelopeSvc::m_fallbackR

private

Initial value:

{{
      {this, "FallbackUndefinedR", {}} 
      , {this, "FallbackInDetR", {}}
      , {this, "FallbackBeamPipeR", {}}
      , {this, "FallbackCaloR", {}}
      , {this, "FallbackMuonR", {}}
      , {this, "FallbackCavernR", {}}
    }}

Definition at line 103 of file DetDescrDBEnvelopeSvc.h.

                                                                         {{
      {this, "FallbackUndefinedR", {}} //Dummy
      , {this, "FallbackInDetR", {}}
      , {this, "FallbackBeamPipeR", {}}
      , {this, "FallbackCaloR", {}}
      , {this, "FallbackMuonR", {}}
      , {this, "FallbackCavernR", {}}
    }};

m_fallbackZ

std::array<DoubleArrayProperty,AtlasDetDescr::fNumAtlasRegions> DetDescrDBEnvelopeSvc::m_fallbackZ

private

Initial value:

{{
      {this, "FallbackUndefinedZ", {}} 
      , {this, "FallbackInDetZ", {}}
      , {this, "FallbackBeamPipeZ", {}}
      , {this, "FallbackCaloZ", {}}
      , {this, "FallbackMuonZ", {}}
      , {this, "FallbackCavernZ", {}}
    }}

Definition at line 112 of file DetDescrDBEnvelopeSvc.h.

                                                                         {{
      {this, "FallbackUndefinedZ", {}} //Dummy
      , {this, "FallbackInDetZ", {}}
      , {this, "FallbackBeamPipeZ", {}}
      , {this, "FallbackCaloZ", {}}
      , {this, "FallbackMuonZ", {}}
      , {this, "FallbackCavernZ", {}}
    }};

m_geoModelSvc

ServiceHandle<IGeoModelSvc> DetDescrDBEnvelopeSvc::m_geoModelSvc {this, "GeoModelSvc", "GeoModelSvc"}

private

ATLAS GeoModel.

Definition at line 77 of file DetDescrDBEnvelopeSvc.h.

{this, "GeoModelSvc", "GeoModelSvc"};

m_node

std::array<StringProperty,AtlasDetDescr::fNumAtlasRegions> DetDescrDBEnvelopeSvc::m_node

private

Initial value:

{{
      {this, "DBUndefinedNode", ""} 
      , {this, "DBInDetNode","InDetEnvelope"}
      , {this, "DBBeamPipeNode", "BeamPipeEnvelope"}
      , {this, "DBCaloNode", "CaloEnvelope"}
      , {this, "DBMSNode", "MuonEnvelope"}
      , {this, "DBCavernNode", "CavernEnvelope"}
    }}

the names of the DB nodes for the respective AtlasRegion

Definition at line 84 of file DetDescrDBEnvelopeSvc.h.

                                                               {{
      {this, "DBUndefinedNode", ""} // Dummy
      , {this, "DBInDetNode","InDetEnvelope"}
      , {this, "DBBeamPipeNode", "BeamPipeEnvelope"}
      , {this, "DBCaloNode", "CaloEnvelope"}
      , {this, "DBMSNode", "MuonEnvelope"}
      , {this, "DBCavernNode", "CavernEnvelope"}
    }};

m_rposz

RZPairVector DetDescrDBEnvelopeSvc::m_rposz[AtlasDetDescr::fNumAtlasRegions] {}

private

internal (r,z) representation for the positive z-side only, one RZPairVector for each AtlasRegion

Definition at line 97 of file DetDescrDBEnvelopeSvc.h.

{};

m_rz

RZPairVector DetDescrDBEnvelopeSvc::m_rz[AtlasDetDescr::fNumAtlasRegions] {}

private

internal (r,z) representation, one RZPairVector for each AtlasRegion

Definition at line 94 of file DetDescrDBEnvelopeSvc.h.

{};

---

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

• DetDescrDBEnvelopeSvc.h
• DetDescrDBEnvelopeSvc.cxx