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.
StatusCode	initialize ()
	AthService initialize method.
StatusCode	finalize ()
	AthService finalize method.
const RZPairVector &	getRZBoundary (AtlasDetDescr::AtlasRegion region) const
	return a vector of (r,z) pairs, defining the respective envelope
const RZPairVector &	getRPositiveZBoundary (AtlasDetDescr::AtlasRegion region) const
	return a vector of (r,z) pairs, defining the envelope on the z>0 region

Private Member Functions
StatusCode	retrieveRZBoundaryOptionalFallback (std::string &dbNode, FallbackDoubleVector &r, FallbackDoubleVector &z, RZPairVector &rzVec)
	retrieve and store the (r,z) values locally for the given DB node.
StatusCode	retrieveRZBoundary (std::string &node, RZPairVector &rzVec)
	retrieve and store the (r,z) values locally for the given DB node
StatusCode	fallbackRZBoundary (FallbackDoubleVector &r, 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
	main DDDB node for the ATLAS detector
std::string	m_atlasVersionTag
std::string	m_node [AtlasDetDescr::fNumAtlasRegions]
	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
bool	m_allowFallback
	fallback solution, in case something goes wrong with the DB
bool	m_doFallback
FallbackDoubleVector	m_fallbackR [AtlasDetDescr::fNumAtlasRegions]
FallbackDoubleVector	m_fallbackZ [AtlasDetDescr::fNumAtlasRegions]

Detailed Description

Definition at line 33 of file DetDescrDBEnvelopeSvc.h.

Constructor & Destructor Documentation

DetDescrDBEnvelopeSvc()

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

public AthService constructor

Constructor.

Definition at line 31 of file DetDescrDBEnvelopeSvc.cxx.

                                                                                    :
  base_class(name,svc),
  m_atlasNode("ATLAS"),
  m_atlasVersionTag("AUTO"),
  m_node(),
  m_rz(),
  m_rposz(),
  m_allowFallback(false),
  m_doFallback(false),
  m_fallbackR(),
  m_fallbackZ()
{
  declareProperty( "DBBeamPipeNode"  , m_node[AtlasDetDescr::fAtlasForward]="BeamPipeEnvelope"  );
  declareProperty( "DBInDetNode"     , m_node[AtlasDetDescr::fAtlasID]="InDetEnvelope"          );
  declareProperty( "DBCaloNode"      , m_node[AtlasDetDescr::fAtlasCalo]="CaloEnvelope"       );
  declareProperty( "DBMSNode"        , m_node[AtlasDetDescr::fAtlasMS]="MuonEnvelope"           );
  declareProperty( "DBCavernNode"    , m_node[AtlasDetDescr::fAtlasCavern]="CavernEnvelope" );
 
  // in case something goes wrong with the DB, the user can define 
  // fallback RZ values
  declareProperty( "EnableFallback"        , m_allowFallback                 );
  declareProperty( "FallbackBeamPipeR"     , m_fallbackR[AtlasDetDescr::fAtlasForward] );
  declareProperty( "FallbackBeamPipeZ"     , m_fallbackZ[AtlasDetDescr::fAtlasForward] );
  declareProperty( "FallbackInDetR"        , m_fallbackR[AtlasDetDescr::fAtlasID]      );
  declareProperty( "FallbackInDetZ"        , m_fallbackZ[AtlasDetDescr::fAtlasID]      );
  declareProperty( "FallbackCaloR"         , m_fallbackR[AtlasDetDescr::fAtlasCalo]    );
  declareProperty( "FallbackCaloZ"         , m_fallbackZ[AtlasDetDescr::fAtlasCalo]    );
  declareProperty( "FallbackMuonR"         , m_fallbackR[AtlasDetDescr::fAtlasMS]      );
  declareProperty( "FallbackMuonZ"         , m_fallbackZ[AtlasDetDescr::fAtlasMS]      );
  declareProperty( "FallbackCavernR"       , m_fallbackR[AtlasDetDescr::fAtlasCavern]  );
  declareProperty( "FallbackCavernZ"       , m_fallbackZ[AtlasDetDescr::fAtlasCavern]  );
}

~DetDescrDBEnvelopeSvc()

DetDescrDBEnvelopeSvc::~DetDescrDBEnvelopeSvc

(

)

Destructor.

Definition at line 65 of file DetDescrDBEnvelopeSvc.cxx.

{
  // free memory
  // TODO :)
}

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 73 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 ( FallbackDoubleVector & r, 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 269 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;
}

finalize()

StatusCode DetDescrDBEnvelopeSvc::finalize

(

)

AthService finalize method.

Athena AthService finalize hook.

Definition at line 173 of file DetDescrDBEnvelopeSvc.cxx.

{
  return StatusCode::SUCCESS;
}

getRPositiveZBoundary()

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

inline

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

Definition at line 52 of file DetDescrDBEnvelopeSvc.h.

                      { return m_rposz[region]; }

getRZBoundary()

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

inline

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

Definition at line 48 of file DetDescrDBEnvelopeSvc.h.

                      { return m_rz[region]; }

initialize()

StatusCode DetDescrDBEnvelopeSvc::initialize

(

)

AthService initialize method.

Athena AthService initialize hook.

Definition at line 91 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],
                                                          m_fallbackR[region],
                                                          m_fallbackZ[region],
                                                          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], m_fallbackZ[region], 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 ( 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 211 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 ( std::string & dbNode, FallbackDoubleVector & r, 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 181 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

bool DetDescrDBEnvelopeSvc::m_allowFallback

private

fallback solution, in case something goes wrong with the DB

Python flag

Definition at line 96 of file DetDescrDBEnvelopeSvc.h.

m_atlasNode

std::string DetDescrDBEnvelopeSvc::m_atlasNode

private

main DDDB node for the ATLAS detector

Definition at line 83 of file DetDescrDBEnvelopeSvc.h.

m_atlasVersionTag

std::string DetDescrDBEnvelopeSvc::m_atlasVersionTag

private

Definition at line 84 of file DetDescrDBEnvelopeSvc.h.

m_dbAccess

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

private

the DetectorDescription database access method

Definition at line 77 of file DetDescrDBEnvelopeSvc.h.

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

m_doFallback

bool DetDescrDBEnvelopeSvc::m_doFallback

private

Definition at line 97 of file DetDescrDBEnvelopeSvc.h.

m_fallbackR

FallbackDoubleVector DetDescrDBEnvelopeSvc::m_fallbackR[AtlasDetDescr::fNumAtlasRegions]

private

Definition at line 98 of file DetDescrDBEnvelopeSvc.h.

m_fallbackZ

FallbackDoubleVector DetDescrDBEnvelopeSvc::m_fallbackZ[AtlasDetDescr::fNumAtlasRegions]

private

Definition at line 99 of file DetDescrDBEnvelopeSvc.h.

m_geoModelSvc

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

private

ATLAS GeoModel.

Definition at line 80 of file DetDescrDBEnvelopeSvc.h.

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

m_node

std::string DetDescrDBEnvelopeSvc::m_node[AtlasDetDescr::fNumAtlasRegions]

private

the names of the DB nodes for the respective AtlasRegion

Definition at line 87 of file DetDescrDBEnvelopeSvc.h.

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 93 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 90 of file DetDescrDBEnvelopeSvc.h.

---

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

• DetDescrDBEnvelopeSvc.h
• DetDescrDBEnvelopeSvc.cxx