InDet::InDetBoundaryCheckTool Class Reference

#include <InDetBoundaryCheckTool.h>

Inheritance diagram for InDet::InDetBoundaryCheckTool:

Collaboration diagram for InDet::InDetBoundaryCheckTool:

Public Member Functions
	InDetBoundaryCheckTool (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual Trk::BoundaryCheckResult	boundaryCheck (const Trk::TrackParameters &) const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	isAlivePixel (const InDetDD::SiDetectorElement &element, const Trk::TrackParameters &parameters) const
bool	isAliveSCT (const InDetDD::SiDetectorElement &element, const Trk::TrackParameters &parameters) const
bool	isBadSCTChipStrip (const InDet::SiDetectorElementStatus *, const Identifier &, const Trk::TrackParameters &, const InDetDD::SiDetectorElement &) const
Trk::BoundaryCheckResult	boundaryCheckSiElement (const InDetDD::SiDetectorElement &, const Trk::TrackParameters &) const
SG::ReadHandle< InDet::SiDetectorElementStatus >	getSCTDetElStatus (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IGeoModelSvc >	m_geoModelSvc {this, "GeoModelSvc", "GeoModelSvc"}
ToolHandle< IInDetConditionsTool >	m_sctCondSummaryTool
ToolHandle< IInDetTestPixelLayerTool >	m_pixelLayerTool
const AtlasDetectorID *	m_atlasId
Gaudi::Property< double >	m_etaTol {this, "ToleranceEta", 3.0}
	eta and phi tolerances
Gaudi::Property< double >	m_phiTol {this, "TolerancePhi", 3.0}
Gaudi::Property< bool >	m_usePixel {this, "UsePixel", true}
	Control usage of pixel and SCT info.
Gaudi::Property< bool >	m_useSCT {this, "UseSCT", true}
Gaudi::Property< bool >	m_checkBadSCT {this, "CheckBadSCT", true}
	Control check of bad SCT chip (should be false for ITk Strip)
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_sctDetElStatus {this, "SCTDetElStatus", "", "Key of SiDetectorElementStatus for SCT"}
	Optional read handle to get status data to test whether a SCT detector element is good.
const SCT_ID *	m_sctID {nullptr}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 22 of file InDetBoundaryCheckTool.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

InDetBoundaryCheckTool()

InDet::InDetBoundaryCheckTool::InDetBoundaryCheckTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 13 of file InDetBoundaryCheckTool.cxx.

 :
    AthAlgTool(t, n, p),
    m_atlasId(nullptr)
{
    declareInterface<IBoundaryCheckTool>(this);
}

Member Function Documentation

boundaryCheck()

Trk::BoundaryCheckResult InDet::InDetBoundaryCheckTool::boundaryCheck ( const Trk::TrackParameters & parameters ) const

overridevirtual

Implements Trk::IBoundaryCheckTool.

Definition at line 205 of file InDetBoundaryCheckTool.cxx.

        {
    /*
     * Retrieve the detector element associated with our track parameters. If
     * such an element does not exist for whatever reason, return a negative
     * result.
     */
    const Trk::TrkDetElementBase *element = parameters.associatedSurface().associatedDetectorElement();
 
    if (element == nullptr) {
        return Trk::BoundaryCheckResult::Error;
    }
 
    /*
     * Try to see if detector element is a silicon element, otherwise return a
     * negative result: this tool is not designed to work on non-silicon
     * elements.
     */
    const InDetDD::SiDetectorElement *siElement =
        (element->detectorType() == Trk::DetectorElemType::Silicon)
            ? static_cast<const InDetDD::SiDetectorElement *>(element)
            : nullptr;
 
    if (siElement != nullptr) {
        return boundaryCheckSiElement(*siElement, parameters);
    } else {
        ATH_MSG_DEBUG("TrackParameters do not belong to a type of element we can process");
        return Trk::BoundaryCheckResult::Error;
    }
}

boundaryCheckSiElement()

Trk::BoundaryCheckResult InDet::InDetBoundaryCheckTool::boundaryCheckSiElement ( const InDetDD::SiDetectorElement & siElement, const Trk::TrackParameters & parameters ) const

private

catch if we are on the edge of an active element

Definition at line 77 of file InDetBoundaryCheckTool.cxx.

        {
    /*
     * We're supporting SCT and Pixel elements. Some of the checking code can
     * be shared, and some of it is different for these detector types. This
     * method will perform all the shared checks that apply to both SCTs and
     * pixels.
     */
    double phitol;
    double etatol;
 
    /*
     * We set our \phi and \eta tolerances by scaling the configured value in
     * the tool's parameters by the standard deviation of the relative
     * positions. If we do not have a covariance matrix to gather these \sigma
     * values from, we use default parameters of 2.5 for \phi and 5.0 for
     * \eta.
     */
    if (parameters.covariance() != nullptr) {
        /*
         * From the covariance matrix, we grab the diagonal to get the
         * variance vector. Then, if we take the component-wise square root
         * of that, we get a vector of \sigma. Then all we need to do is use
         * the right indexes to retrieve the values for \eta and \phi.
         */
        Eigen::Matrix<double, 5, 1> var = parameters.covariance()->diagonal().cwiseSqrt();
        etatol = m_etaTol.value() * var(Trk::iEta);
        phitol = m_phiTol.value() * var(Trk::iPhi);
    } else {
        /*
         * If we don't have the covariance matrix, set our defaults. In the
         * future, these two default values could be lifted into separate
         * configuration parameters.
         */
        phitol = 2.5;
        etatol = 5;
    }
 
 
    /*
     * Next, we determine whether the hit is in the active region of the
     * element using the SiDetectorElement::inDetector() method followed by
     * the SiIntersect::in() method.
     */
    InDetDD::SiIntersect intersection = siElement.inDetector(
        parameters.localPosition(), phitol, etatol
    );

    if (intersection.nearBoundary()){
 
        /*
         * If we are around the boundary, we return a special state which
         * will not be counted as a hole or missing hit in the pattern,
         * while still being recorded on the trajectory for later
         * refinement.
         */
        return Trk::BoundaryCheckResult::OnEdge;
    }
 
    if (intersection.out()) {
        /*
         * In this case, we are _not_ inside the active region of the element.
         */
        return Trk::BoundaryCheckResult::Outside;
    }
 
    /* Now, to proceed further we need to confirm that the module is actually active
    */
 
    Identifier id = siElement.identify();
 
    bool alive;
 
    /*
     * If we have not yet determined our hit to lie in any inactive region, we
     * check whether the module hit is actually alive. For this, we deletage
     * to two dedicated methods which essentially wrap external tools which
     * know about element states.
     */
    if (m_usePixel.value() && m_atlasId->is_pixel(id)) {
        alive = isAlivePixel(siElement, parameters);
    } else if (m_useSCT.value() && m_atlasId->is_sct(id)) {
        alive = isAliveSCT(siElement, parameters);
    } else {
        ATH_MSG_WARNING("Unsupported identifier type! "+m_atlasId->print_to_string(id));
        return Trk::BoundaryCheckResult::Error;
    }
 
    /*
     * We now have all the necessary information to make a judgement about the
     * track parameters.
     */
    if (alive) {
 
        /*
        * now, we check whether the local position on the silicon element is
        * near the bonding gap of the module, which is insensitive. For this, we
        * can simply delegate to the SiDetectorElement::newBondGap() method.
        *
        * Keen-eyed readers may note that bond gaps are only relevant for SCT
        * modules and that Pixels do not have them. Therefore, we can technically
        * consider this a check relevant only to SCTs. However, as this logic is
        * abstracted into the SiDetectorElement class, we will treat is as a
        * shared property and a shared check.
        */
        if (siElement.nearBondGap(parameters.localPosition(), etatol )) {
            return Trk::BoundaryCheckResult::Insensitive;
        }
        /*
         * If the module is alive and we hit the active region on it, we know
         * we have a good hit. Note that this is the only way we can return a
         * Candidate result! It's the only success state.
         */
        return Trk::BoundaryCheckResult::Candidate;
 
    }
    else {
        /*
         * Finally, if the module is not alive, we simply return a DeadElement
         * result.
         */
        return Trk::BoundaryCheckResult::DeadElement;
    }
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ return m_detStore; }

evtStore()

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.

{ 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

finalize()

StatusCode InDet::InDetBoundaryCheckTool::finalize ( )

overridevirtual

Definition at line 53 of file InDetBoundaryCheckTool.cxx.

                                                 {
    return AlgTool::finalize();
}

getSCTDetElStatus()

SG::ReadHandle< InDet::SiDetectorElementStatus > InDet::InDetBoundaryCheckTool::getSCTDetElStatus ( const EventContext & ctx ) const

inlineprivate

Definition at line 101 of file InDetBoundaryCheckTool.h.

                                                                                                                             {
       SG::ReadHandle<InDet::SiDetectorElementStatus> sctDetElStatus;
       if (!m_sctDetElStatus.empty()) {
          sctDetElStatus = SG::ReadHandle<InDet::SiDetectorElementStatus>(m_sctDetElStatus, ctx);
          if (!sctDetElStatus.isValid()) {
             std::stringstream msg;
             msg << "Failed to get " << m_sctDetElStatus.key() << " from StoreGate in " << name();
             throw std::runtime_error(msg.str());
          }
       }
       return sctDetElStatus;
    }

initialize()

StatusCode InDet::InDetBoundaryCheckTool::initialize ( )

overridevirtual

Definition at line 24 of file InDetBoundaryCheckTool.cxx.

                                                   {
    StatusCode sc = AlgTool::initialize();
 
    if (sc.isFailure()) return sc;
 
    ATH_CHECK(detStore()->retrieve(m_atlasId, "AtlasID"));
 
    ATH_CHECK(m_pixelLayerTool.retrieve(DisableTool{!m_usePixel.value()}));
    ATH_CHECK(m_sctCondSummaryTool.retrieve(DisableTool{!m_useSCT.value() || (!m_sctDetElStatus.empty() && !VALIDATE_STATUS_ARRAY_ACTIVATED)}));
    ATH_CHECK(m_sctDetElStatus.initialize(m_useSCT.value() && !m_sctDetElStatus.empty()) );
    if (m_useSCT.value() && !m_sctDetElStatus.empty()) {
       ATH_CHECK( detStore()->retrieve(m_sctID,"SCT_ID") );
    }
 
    if (m_checkBadSCT.value()) {
        /*
         * Check if ITk Strip is used because isBadSCTChipStrip method is
         * valid only for SCT.
         */
        ATH_CHECK(m_geoModelSvc.retrieve());
 
        if (m_geoModelSvc->geoConfig()==GeoModel::GEO_RUN4) {
            m_checkBadSCT.set(false);
            ATH_MSG_WARNING("Since ITk Strip is used, m_check_bad_sct is turned off.");
        }
    }
    return StatusCode::SUCCESS;
}

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.

interfaceID()

const InterfaceID & Trk::IBoundaryCheckTool::interfaceID ( )

inlinestaticinherited

Definition at line 27 of file IBoundaryCheckTool.h.

                                                {
            return IID_IBoundaryCheckTool;
        }

isAlivePixel()

bool InDet::InDetBoundaryCheckTool::isAlivePixel ( const InDetDD::SiDetectorElement & element, const Trk::TrackParameters & parameters ) const

private

Definition at line 57 of file InDetBoundaryCheckTool.cxx.

        {
    return m_pixelLayerTool->expectHit(&parameters);
}

isAliveSCT()

bool InDet::InDetBoundaryCheckTool::isAliveSCT ( const InDetDD::SiDetectorElement & element, const Trk::TrackParameters & parameters ) const

private

Definition at line 64 of file InDetBoundaryCheckTool.cxx.

        {
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    SG::ReadHandle<InDet::SiDetectorElementStatus> sctDetElStatus( getSCTDetElStatus(ctx));
    if (m_checkBadSCT.value() && isBadSCTChipStrip(!m_sctDetElStatus.empty() ? sctDetElStatus.cptr() : nullptr, element.identify(), parameters, element)) {
        return false;
    }
    VALIDATE_STATUS_ARRAY(!m_sctDetElStatus.empty(),sctDetElStatus->isGood(element.identifyHash()), m_sctCondSummaryTool->isGood(element.identifyHash(), ctx));
    return !m_sctDetElStatus.empty() ? sctDetElStatus->isGood(element.identifyHash()) : m_sctCondSummaryTool->isGood(element.identifyHash(), ctx);
}

isBadSCTChipStrip()

bool InDet::InDetBoundaryCheckTool::isBadSCTChipStrip ( const InDet::SiDetectorElementStatus * sctDetElStatus, const Identifier & waferId, const Trk::TrackParameters & parameters, const InDetDD::SiDetectorElement & siElement ) const

private

Definition at line 237 of file InDetBoundaryCheckTool.cxx.

        {
    // Check if the track passes through a bad SCT ABCD chip or a bad SCT strip.
    // A chip and a strip are determined by the parameter position.
    // Algorithm is based on InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitEffMonTool.cxx
 
    // Check the input.
    if (!m_atlasId->is_sct(waferId)) {
        ATH_MSG_ERROR(waferId << " is not an SCT Identifier");
        return true;
    }
 
    // Get strip id from local position.
    // Due to the limited position resolution, we may pick up a neighboring strip...
    const Amg::Vector2D localPos(parameters.localPosition());
    const Identifier stripIdentifier(siElement.identifierOfPosition(localPos));
 
    if (!m_atlasId->is_sct(stripIdentifier)) {
        ATH_MSG_WARNING(stripIdentifier << " is not an SCT Identifier");
        return true;
    }
 
    {
      const EventContext& ctx{Gaudi::Hive::currentContext()};
       if (sctDetElStatus) {
          unsigned int chip_i=SCT::getGeometricalChipID(*m_sctID, stripIdentifier);
          VALIDATE_STATUS_ARRAY(sctDetElStatus,sctDetElStatus->isChipGood(siElement.identifyHash(), chip_i) && sctDetElStatus->isCellGood(siElement.identifyHash(), m_sctID->strip(stripIdentifier) ),m_sctCondSummaryTool->isGood(stripIdentifier, InDetConditions::SCT_CHIP, ctx) && m_sctCondSummaryTool->isGood(stripIdentifier, InDetConditions::SCT_STRIP, ctx));
          if (!sctDetElStatus->isChipGood(siElement.identifyHash(), chip_i)) return true;
 
          return !sctDetElStatus->isCellGood(siElement.identifyHash(), m_sctID->strip(stripIdentifier) );
       }
       else {
          if (!m_sctCondSummaryTool->isGood(stripIdentifier, InDetConditions::SCT_CHIP, ctx)) {
             // The position is on a bad chip.
             return true;
          } else if (!m_sctCondSummaryTool->isGood(stripIdentifier, InDetConditions::SCT_STRIP, ctx)) {
             // The position is on a bad strip. (We may need to check neighboring strips.)
             return true;
          }
       }
    }
    return false;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_atlasId

const AtlasDetectorID* InDet::InDetBoundaryCheckTool::m_atlasId

private

Definition at line 78 of file InDetBoundaryCheckTool.h.

m_checkBadSCT

Gaudi::Property<bool> InDet::InDetBoundaryCheckTool::m_checkBadSCT {this, "CheckBadSCT", true}

private

Control check of bad SCT chip (should be false for ITk Strip)

Definition at line 89 of file InDetBoundaryCheckTool.h.

{this, "CheckBadSCT", true};

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_etaTol

Gaudi::Property<double> InDet::InDetBoundaryCheckTool::m_etaTol {this, "ToleranceEta", 3.0}

private

eta and phi tolerances

Definition at line 81 of file InDetBoundaryCheckTool.h.

{this, "ToleranceEta", 3.0};

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_geoModelSvc

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

private

Definition at line 61 of file InDetBoundaryCheckTool.h.

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

m_phiTol

Gaudi::Property<double> InDet::InDetBoundaryCheckTool::m_phiTol {this, "TolerancePhi", 3.0}

private

Definition at line 82 of file InDetBoundaryCheckTool.h.

{this, "TolerancePhi", 3.0};

m_pixelLayerTool

ToolHandle<IInDetTestPixelLayerTool> InDet::InDetBoundaryCheckTool::m_pixelLayerTool

private

Initial value:

{
                this,
                "PixelLayerTool",
        "InDet::InDetTestPixelLayerTool",
        "Tool to retrieve pixel conditions summary"
        }

Definition at line 71 of file InDetBoundaryCheckTool.h.

                                                                 {
                this,
                "PixelLayerTool",
        "InDet::InDetTestPixelLayerTool",
        "Tool to retrieve pixel conditions summary"
        };

m_sctCondSummaryTool

ToolHandle<IInDetConditionsTool> InDet::InDetBoundaryCheckTool::m_sctCondSummaryTool

private

Initial value:

{
                this,
                "SctSummaryTool",
                "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool",
                "Tool to retrieve SCT Conditions summary"
            }

Definition at line 64 of file InDetBoundaryCheckTool.h.

                                                                 {
                this,
                "SctSummaryTool",
                "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool",
                "Tool to retrieve SCT Conditions summary"
            };

m_sctDetElStatus

SG::ReadHandleKey<InDet::SiDetectorElementStatus> InDet::InDetBoundaryCheckTool::m_sctDetElStatus {this, "SCTDetElStatus", "", "Key of SiDetectorElementStatus for SCT"}

private

Optional read handle to get status data to test whether a SCT detector element is good.

If set to e.g. SCTDetectorElementStatus the event data will be used instead of the SCT conditions summary tool.

Definition at line 94 of file InDetBoundaryCheckTool.h.

{this, "SCTDetElStatus", "", "Key of SiDetectorElementStatus for SCT"};

m_sctID

const SCT_ID* InDet::InDetBoundaryCheckTool::m_sctID {nullptr}

private

Definition at line 97 of file InDetBoundaryCheckTool.h.

{nullptr};

m_usePixel

Gaudi::Property<bool> InDet::InDetBoundaryCheckTool::m_usePixel {this, "UsePixel", true}

private

Control usage of pixel and SCT info.

Definition at line 85 of file InDetBoundaryCheckTool.h.

{this, "UsePixel", true};

m_useSCT

Gaudi::Property<bool> InDet::InDetBoundaryCheckTool::m_useSCT {this, "UseSCT", true}

private

Definition at line 86 of file InDetBoundaryCheckTool.h.

{this, "UseSCT", true};

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:

• InDetBoundaryCheckTool.h
• InDetBoundaryCheckTool.cxx