InDet::InDetTestPixelLayerTool Class Reference

#include <InDetTestPixelLayerTool.h>

Inheritance diagram for InDet::InDetTestPixelLayerTool:

Collaboration diagram for InDet::InDetTestPixelLayerTool:

Public Member Functions
	InDetTestPixelLayerTool (const std::string &name, const std::string &n, const IInterface *p)
virtual StatusCode	initialize () override final
virtual bool	expectHitInPixelLayer (const EventContext &ctx, const Trk::TrackParticleBase *, int pixel_layer) const override final
virtual bool	expectHitInPixelLayer (const EventContext &ctx, const Trk::Track *, int pixel_layer, bool checkBarrelOnly=false) const override final
virtual bool	expectHitInPixelLayer (const EventContext &ctx, const Trk::TrackParameters *trackpar, int pixel_layer, bool checkBarrelOnly=false) const override final
virtual bool	expectHit (const Trk::TrackParameters *trackpar) const override final
virtual bool	getTrackStateOnPixelLayerInfo (const Trk::TrackParticleBase *, std::vector< TrackStateOnPixelLayerInfo > &infoList) const override final
virtual bool	getTrackStateOnPixelLayerInfo (const Trk::Track *, std::vector< TrackStateOnPixelLayerInfo > &infoList) const override final
virtual bool	getTrackStateOnPixelLayerInfo (const Trk::TrackParameters *trackpar, std::vector< TrackStateOnPixelLayerInfo > &infoList, int pixel_layer=-1, bool checkBarrelOnly=false) const override final
virtual double	getFracGood (const Trk::TrackParticleBase *trackpar, int pixel_layer) const override final
virtual double	getFracGood (const Trk::TrackParameters *trackpar, int pixel_layer) const override final
bool	expectHitInInnermostPixelLayer (const EventContext &ctx, const Trk::Track *track) const
bool	expectHitInInnermostPixelLayer (const Trk::Track *track) const
bool	expectHitInInnermostPixelLayer (const Trk::TrackParameters *trackpar) const
bool	expectHitInNextToInnermostPixelLayer (const EventContext &ctx, const Trk::Track *track) const
bool	expectHitInNextToInnermostPixelLayer (const Trk::Track *track) const
bool	expectHitInNextToInnermostPixelLayer (const Trk::TrackParameters *trackpar) const
bool	getTrackStateOnInnermostPixelLayerInfo (const Trk::TrackParameters *trackpar, std::vector< TrackStateOnPixelLayerInfo > &infoList) const
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	isActive (const Trk::TrackParameters *trackpar) const
bool	getPixelLayerParameters (const EventContext &ctx, const Trk::TrackParameters *trackpar, std::vector< std::unique_ptr< const Trk::TrackParameters > > &pixelLayerParam) const
bool	getPixelLayerParameters (const Trk::TrackParameters *trackpar, std::vector< std::unique_ptr< const Trk::TrackParameters > > &pixelLayerParam) const
double	getFracGood (const Trk::TrackParameters *trackpar, double phiRegionSize, double etaRegionSize, const InDet::SiDetectorElementStatus *pixelDetElStatus) const
SG::ReadHandle< InDet::SiDetectorElementStatus >	getPixelDetElStatus (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
ToolHandle< Trk::IExtrapolator >	m_extrapolator
	Pointer to Extrapolator AlgTool.
ToolHandle< IInDetConditionsTool >	m_pixelCondSummaryTool
	Handles to IConditionsSummaryServices for Pixels.
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_pixelDetElStatus {this, "PixelDetElStatus", "", "Key of SiDetectorElementStatus for Pixel"}
	Optional read handle to get status data to test whether a pixel detector element is good.
const AtlasDetectorID *	m_idHelper
	detector helper
const PixelID *	m_pixelId
	ID pixel helper.
BooleanProperty	m_checkActiveAreas {this, "CheckActiveAreas", true}
BooleanProperty	m_checkDeadRegions {this, "CheckDeadRegions", true}
BooleanProperty	m_checkDisabledFEs {this, "CheckDisabledFEs", true}
DoubleProperty	m_phiRegionSize {this, "PhiRegionSize", 3.}
DoubleProperty	m_etaRegionSize {this, "EtaRegionSize", 3.}
DoubleProperty	m_goodFracCut {this, "GoodFracCut", 0.5}
DoubleProperty	m_outerRadius {this, "OuterRadius", 230.}
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 45 of file InDetTestPixelLayerTool.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

InDetTestPixelLayerTool()

InDet::InDetTestPixelLayerTool::InDetTestPixelLayerTool	(	const std::string &	name,
		const std::string &	n,
		const IInterface *	p )

Definition at line 30 of file InDetTestPixelLayerTool.cxx.

  : AthAlgTool(name, n, p)
  , m_idHelper(nullptr)
  , m_pixelId(nullptr)
{
  declareInterface<IInDetTestPixelLayerTool>(this);
}

Member Function Documentation

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; }

expectHit()

bool InDet::InDet::InDetTestPixelLayerTool::expectHit ( const Trk::TrackParameters * trackpar ) const

finaloverridevirtual

will be set to true if at least one good module is passed

pass good module -> hit is expected on pixelLayer

check dead regions

pass good module -> hit is expected on pixelLayer

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 199 of file InDetTestPixelLayerTool.cxx.

{
  bool expect_hit =
    false; 
 
  Identifier id =
    trackpar->associatedSurface().associatedDetectorElement()->identify();
 
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadHandle<InDet::SiDetectorElementStatus> pixelDetElStatus(getPixelDetElStatus(ctx));
 
  VALIDATE_STATUS_ARRAY(
    !m_pixelDetElStatus.empty(),
    pixelDetElStatus->isGood(trackpar->associatedSurface().associatedDetectorElement()->identifyHash()),
    m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx));
  if ((!m_pixelDetElStatus.empty() &&
       pixelDetElStatus->isGood(trackpar->associatedSurface().associatedDetectorElement()->identifyHash())) ||
      (m_pixelDetElStatus.empty() && m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx))) {
 
    if (m_checkDeadRegions) {
 
      double fracGood = getFracGood(
        trackpar, m_phiRegionSize, m_etaRegionSize, !m_pixelDetElStatus.empty() ? pixelDetElStatus.cptr() : nullptr);
      if (fracGood > m_goodFracCut && fracGood >= 0) {
        ATH_MSG_DEBUG("Condition Summary: b-layer good");
        expect_hit = true; 
      } else {
        ATH_MSG_DEBUG("b-layer in dead region: fracGood = " << fracGood);
      }
 
    } else { 
      ATH_MSG_DEBUG("Condition Summary: not checking dead regions");
      expect_hit = true; 
    }
 
  } else {
    ATH_MSG_DEBUG(__LINE__ << "b-layer not good");
  }
 
  return expect_hit;
}

expectHitInInnermostPixelLayer() [1/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInInnermostPixelLayer ( const EventContext & ctx, const Trk::Track * track ) const

inlineinherited

Definition at line 49 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInPixelLayer(ctx, track, 0, true);
  }

expectHitInInnermostPixelLayer() [2/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInInnermostPixelLayer ( const Trk::Track * track ) const

inlineinherited

Definition at line 54 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInInnermostPixelLayer(
      Gaudi::Hive::currentContext(), track);
  }

expectHitInInnermostPixelLayer() [3/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInInnermostPixelLayer ( const Trk::TrackParameters * trackpar ) const

inlineinherited

Definition at line 59 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInPixelLayer(
      Gaudi::Hive::currentContext(), trackpar, 0, true);
  }

expectHitInNextToInnermostPixelLayer() [1/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInNextToInnermostPixelLayer ( const EventContext & ctx, const Trk::Track * track ) const

inlineinherited

Definition at line 65 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInPixelLayer(ctx, track, 1, true);
  }

expectHitInNextToInnermostPixelLayer() [2/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInNextToInnermostPixelLayer ( const Trk::Track * track ) const

inlineinherited

Definition at line 70 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInInnermostPixelLayer(
      Gaudi::Hive::currentContext(), track);
  }

expectHitInNextToInnermostPixelLayer() [3/3]

bool InDet::IInDetTestPixelLayerTool::expectHitInNextToInnermostPixelLayer ( const Trk::TrackParameters * trackpar ) const

inlineinherited

Definition at line 75 of file IInDetTestPixelLayerTool.h.

  {
    return expectHitInPixelLayer(
      Gaudi::Hive::currentContext(), trackpar, 1, true);
  }

expectHitInPixelLayer() [1/3]

bool InDet::InDetTestPixelLayerTool::expectHitInPixelLayer ( const EventContext & ctx, const Trk::Track * track, int pixel_layer, bool checkBarrelOnly = false ) const

finaloverridevirtual

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 68 of file InDetTestPixelLayerTool.cxx.

{
  ATH_MSG_DEBUG("computing expectHitInPixelLayer info");
 
  const Trk::Perigee* mp = track->perigeeParameters();
 
  if (!mp) {
    ATH_MSG_WARNING("Found Track with no perigee parameters: no b-layer info "
                    "will be provided ");
    return false;
  } else {
    ATH_MSG_DEBUG("Track perigee parameters");
    return this->expectHitInPixelLayer(ctx, mp, pixel_layer, checkBarrelOnly);
  }
}

expectHitInPixelLayer() [2/3]

bool InDet::InDetTestPixelLayerTool::expectHitInPixelLayer ( const EventContext & ctx, const Trk::TrackParameters * trackpar, int pixel_layer, bool checkBarrelOnly = false ) const

finaloverridevirtual

will be set to true if at least one good module is passed

pass good module -> hit is expected on pixelLayer

check dead regions

pass good module -> hit is expected on pixelLayer

check active area (check edges)

pass good module -> hit is expected on pixelLayer

pixelLayer param

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 120 of file InDetTestPixelLayerTool.cxx.

{
  bool expect_hit = false; 
 
  std::vector<std::unique_ptr<const Trk::TrackParameters>> pixelLayerParam;
  if (!this->getPixelLayerParameters(ctx, trackpar, pixelLayerParam)) {
    ATH_MSG_DEBUG("Failed to get pixel layer parameters!");
    return false;
  }
 
  SG::ReadHandle<InDet::SiDetectorElementStatus> pixelDetElStatus(getPixelDetElStatus(ctx));
  for (std::unique_ptr<const Trk::TrackParameters>& p : pixelLayerParam) {
 
    if (!(p->associatedSurface().associatedDetectorElement()))
      continue;
    Identifier id =
      p->associatedSurface().associatedDetectorElement()->identify();
 
    if (checkBarrelOnly && !m_pixelId->is_barrel(id)) continue;
    if (m_pixelId->layer_disk(id) != pixel_layer) continue;
 
    VALIDATE_STATUS_ARRAY(!m_pixelDetElStatus.empty(),
                          pixelDetElStatus->isGood(p->associatedSurface().associatedDetectorElement()->identifyHash()),
                          m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx));
 
    if ((!m_pixelDetElStatus.empty() &&
         pixelDetElStatus->isGood(p->associatedSurface().associatedDetectorElement()->identifyHash())) ||
        (m_pixelDetElStatus.empty() && m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx))) {
 
      if (m_checkActiveAreas) {
 
        if (isActive(p.get())) {
 
          if (m_checkDeadRegions) {
 
            double fracGood = getFracGood(p.get(),
                                          m_phiRegionSize,
                                          m_etaRegionSize,
                                          !m_pixelDetElStatus.empty() ? pixelDetElStatus.cptr() : nullptr);
            if (fracGood > m_goodFracCut && fracGood >= 0) {
              ATH_MSG_DEBUG("Condition Summary: b-layer good");
              expect_hit =
                true; 
            } else {
              ATH_MSG_DEBUG("b-layer in dead region: fracGood = " << fracGood);
            }
 
          } else { 
            ATH_MSG_DEBUG("Condition Summary: not checking dead regions");
            expect_hit =
              true; 
          }
 
        } else {
          ATH_MSG_DEBUG(
            "Condition Summary: b-layer good but outside active area");
        }
 
      } 
      else {
        ATH_MSG_DEBUG(
          "Condition Summary: b-layer good, active areas not checked");
        expect_hit = true; 
      }
 
    } else {
      ATH_MSG_DEBUG(__LINE__ << "b-layer not good");
    }
 
  } 
 
  return expect_hit;
}

expectHitInPixelLayer() [3/3]

bool InDet::InDetTestPixelLayerTool::expectHitInPixelLayer ( const EventContext & ctx, const Trk::TrackParticleBase * track, int pixel_layer ) const

finaloverridevirtual

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 88 of file InDetTestPixelLayerTool.cxx.

{
 
  // Need to compute if we do expect a B-layer hit.  If the previous
  // calculation already determined that we don't expect a hit, then we still
  // won't expect one.
 
  if (!track) {
    ATH_MSG_WARNING(
      "Not a valid TrackParticle: no b-layer info will be provided");
    return false;
  }
 
  ATH_MSG_DEBUG("computing expectHitInPixelLayer info");
 
  const Trk::Perigee* mp = track->perigee();
 
  if (!mp) {
    ATH_MSG_WARNING("Found TrackParticle with no perigee parameters: no "
                    "b-layer info will be provided");
    return false;
  } else {
    ATH_MSG_DEBUG("TrackParticle perigee parameters");
    //    mp->dump(mLog);
    return (this->expectHitInPixelLayer(ctx, mp, pixel_layer));
  }
}

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

getFracGood() [1/3]

double InDet::InDet::InDetTestPixelLayerTool::getFracGood ( const Trk::TrackParameters * trackpar, double phiRegionSize, double etaRegionSize, const InDet::SiDetectorElementStatus * pixelDetElStatus ) const

private

not exactly on the edge

not exactly on the edge

Definition at line 600 of file InDetTestPixelLayerTool.cxx.

{
 
  Identifier moduleid =
    trkParam->associatedSurface().associatedDetectorElement()->identify();
  IdentifierHash id_hash = m_pixelId->wafer_hash(moduleid);
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  VALIDATE_STATUS_ARRAY(pixelDetElStatus,pixelDetElStatus->isGood(id_hash), m_pixelCondSummaryTool->isGood(id_hash, ctx));
  bool is_good (  ( pixelDetElStatus && pixelDetElStatus->isGood(id_hash))
                || (!pixelDetElStatus && m_pixelCondSummaryTool->isGood(id_hash, ctx)));
  if (!is_good)
    return 0.;
 
  const Amg::Vector2D& locPos = trkParam->localPosition();
  double locx = locPos[Trk::locX];
  double locy = locPos[Trk::locY];
  double error_locx = -9999;
  double error_locy = -9999;
 
  if (trkParam->covariance()) {
    error_locx = sqrt((*trkParam->covariance())(Trk::locX, Trk::locX));
    error_locy = sqrt((*trkParam->covariance())(Trk::locY, Trk::locY));
  } else {
    ATH_MSG_DEBUG("could not get MeasuredTrackParameters ");
  }
 
  double phitol = 2.5;
  double etatol = 5.;
  if (trkParam->covariance()) {
    phitol = phiRegionSize * error_locx;
    etatol = etaRegionSize * error_locy;
  }
 
  // now, check to see that phitol and etatol extend at least beyond the current
  // pixel
  const auto* tmp = trkParam->associatedSurface().associatedDetectorElement();
  const InDetDD::SiDetectorElement* sielem =
      (tmp != nullptr && tmp->detectorType() == Trk::DetectorElemType::Silicon)
          ? static_cast<const InDetDD::SiDetectorElement*>(tmp)
          : nullptr;
 
  if (!sielem) {
    ATH_MSG_WARNING(
      "Failed to cast TrackParameters associated surface to SiDetectorElement");
    return false;
  }
 
  const InDetDD::PixelModuleDesign* design =
    dynamic_cast<const InDetDD::PixelModuleDesign*>(&sielem->design());
  if (design) {
    phitol = std::max(phitol, design->phiPitch() + 1e-6);
    etatol = std::max(etatol, design->etaPitch() + 1e-6);
  } else {
    ATH_MSG_WARNING(
      "could not get pixel module design, returning 0 for getFracGood");
    return 0.;
  }
 
  Amg::Vector2D LocPos(locx, locy);
 
  double startLocX = locx - phitol;
  double startLocY = locy - etatol;
 
  double endLocX = locx + phitol;
  double endLocY = locy + etatol;
 
  Amg::Vector2D startLocPostmp(startLocX, startLocY);
  Amg::Vector2D endLocPostmp(endLocX, endLocY);
 
  double etaDist = -9999;
  double phiDist = -9999;
 
  if (design) {
    design->distanceToDetectorEdge(LocPos, etaDist, phiDist);
    if (phiDist < 0)
      locx += (std::abs(phiDist) + 1e-6); 
    if (etaDist < 0)
      locy += (std::abs(etaDist) + 1e-6);
    design->distanceToDetectorEdge(startLocPostmp, etaDist, phiDist);
    if (phiDist < 0)
      startLocX += (std::abs(phiDist) + 1e-6); 
    if (etaDist < 0)
      startLocY += (std::abs(etaDist) + 1e-6);
    design->distanceToDetectorEdge(endLocPostmp, etaDist, phiDist);
    if (phiDist < 0)
      endLocX -= (std::abs(phiDist) + 1e-6);
    if (etaDist < 0)
      endLocY -= (std::abs(etaDist) + 1e-6);
  }
 
  LocPos = Amg::Vector2D(locx, locy);
 
  if (m_checkDisabledFEs) {
    const InDetConditions::Hierarchy context = InDetConditions::PIXEL_CHIP;
    InDetDD::PixelDiodeTree::DiodeProxy si_param = design->diodeProxyFromPosition(LocPos);
 
    if (si_param.isValid()) {
      std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx(si_param.computeIndex(LocPos));
      Identifier centreId = m_pixelId->pixel_id(moduleid, diode_idx[0],diode_idx[1]);
      assert( centreId == sielem->identifierOfPosition(LocPos) );
 
      assert( sielem->identifyHash() == m_pixelId->wafer_hash(m_pixelId->wafer_id(centreId)));
      InDetDD::PixelDiodeTree::DiodeProxyWithPosition si_param ( design->diodeProxyFromIdxCachePosition(diode_idx));
      std::uint32_t feValue = design->getFE(si_param);
      VALIDATE_STATUS_ARRAY(!m_pixelDetElStatus.empty(),
                            pixelDetElStatus->isChipGood(id_hash, feValue),
                            m_pixelCondSummaryTool->isGood(centreId, context));
      bool is_chip_good((!m_pixelDetElStatus.empty() &&
                         pixelDetElStatus->isChipGood(id_hash, feValue)) ||
                        (m_pixelDetElStatus.empty() && m_pixelCondSummaryTool->isGood(centreId, context, ctx)));
      if (!is_chip_good){
        return 0.;
      }
    } else {
      ATH_MSG_WARNING("Invalid Identifier, skipping check of FE...");
    }
  }
 
  Amg::Vector2D startLocPos(startLocX, startLocY);
  Amg::Vector2D endLocPos(endLocX, endLocY);
  Identifier startId = sielem->identifierOfPosition(startLocPos);
  Identifier endId = sielem->identifierOfPosition(endLocPos);
 
  if (!startId.is_valid() || !endId.is_valid()) {
    ATH_MSG_WARNING("unvalid identifier: locPos outside module! ");
    return 0.;
  }
 
  double frac =0.;
 
  if (pixelDetElStatus) {
    frac = Pixel::getGoodFraction(*pixelDetElStatus, *design, *m_pixelId, id_hash, startId, endId);
    VALIDATE_STATUS_ARRAY(
      !m_pixelDetElStatus.empty(), frac, m_pixelCondSummaryTool->goodFraction(id_hash, startId, endId, ctx));
 
  } else {
    frac = m_pixelCondSummaryTool->goodFraction(id_hash, startId, endId, ctx);
  }
 
  return frac;
}

getFracGood() [2/3]

double InDet::InDetTestPixelLayerTool::getFracGood ( const Trk::TrackParameters * trackpar, int pixel_layer ) const

finaloverridevirtual

pixelLayer param

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 260 of file InDetTestPixelLayerTool.cxx.

{
  std::vector<std::unique_ptr<const Trk::TrackParameters>> pixelLayerParam;
  if (!this->getPixelLayerParameters(trackpar, pixelLayerParam))
    return -5.;
 
  // now, figure out which layer we're supposed to be checking.
  bool found_layer = false;
  for (std::unique_ptr<const Trk::TrackParameters>& p : pixelLayerParam) {
    if (!(p->associatedSurface().associatedDetectorElement()))
      continue;
    Identifier id =
      p->associatedSurface().associatedDetectorElement()->identify();
 
    if (m_pixelId->layer_disk(id) == pixel_layer){
      found_layer = true;
      break;
    }
  }
 
  // if we're asking for a layer that doesn't exist in the extrapolation, then
  // return.
  if (!found_layer)
    return -7.;
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadHandle<InDet::SiDetectorElementStatus> pixelDetElStatus(getPixelDetElStatus(ctx));
 
  for (std::unique_ptr<const Trk::TrackParameters>& p : pixelLayerParam) {
 
    if (!(p->associatedSurface().associatedDetectorElement()))
      continue;
    Identifier id =
      p->associatedSurface().associatedDetectorElement()->identify();
 
    if (m_pixelId->layer_disk(id) != pixel_layer)
      continue;
 
    VALIDATE_STATUS_ARRAY(
      !m_pixelDetElStatus.empty(),
      pixelDetElStatus->isGood(trackpar->associatedSurface().associatedDetectorElement()->identifyHash()),
      m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx));
    if ((!m_pixelDetElStatus.empty() &&
         pixelDetElStatus->isGood(p->associatedSurface().associatedDetectorElement()->identifyHash())) ||
        (m_pixelDetElStatus.empty() && m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx))) {
 
      if (isActive(p.get())) {
 
        return getFracGood(
          p.get(), m_phiRegionSize, m_etaRegionSize, !m_pixelDetElStatus.empty() ? pixelDetElStatus.cptr() : nullptr);
 
      } else {
        ATH_MSG_DEBUG(
          "Condition Summary: b-layer good but outside active area");
      }
 
    } else {
      ATH_MSG_DEBUG(__LINE__ << "b-layer not good");
    }
 
  } 
 
  return -3.;
}

getFracGood() [3/3]

double InDet::InDet::InDetTestPixelLayerTool::getFracGood ( const Trk::TrackParticleBase * trackpar, int pixel_layer ) const

finaloverridevirtual

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 244 of file InDetTestPixelLayerTool.cxx.

{
  const Trk::Perigee* mp = track->perigee();
 
  if (!mp) {
    ATH_MSG_WARNING("Found Track with no perigee parameters: no b-layer info "
                    "will be provided ");
    return -4.;
  } else {
    ATH_MSG_DEBUG("Track perigee parameters");
    return this->getFracGood(mp, pixel_layer);
  }
}

getPixelDetElStatus()

SG::ReadHandle< InDet::SiDetectorElementStatus > InDet::InDetTestPixelLayerTool::getPixelDetElStatus ( const EventContext & ctx ) const

private

Definition at line 155 of file InDetTestPixelLayerTool.h.

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

getPixelLayerParameters() [1/2]

bool InDet::InDet::InDetTestPixelLayerTool::getPixelLayerParameters ( const EventContext & ctx, const Trk::TrackParameters * trackpar, std::vector< std::unique_ptr< const Trk::TrackParameters > > & pixelLayerParam ) const

private

all params

Definition at line 541 of file InDetTestPixelLayerTool.cxx.

{
  ATH_MSG_DEBUG("Trying to extrapolate to pixelLayer");
 
  if(std::abs(trackpar->position().z())>5000.){
    ATH_MSG_DEBUG("Pathological track parameter well outside of tracking detector");
    ATH_MSG_DEBUG("Propagator might have issue with this, discarding");
    ATH_MSG_VERBOSE("dumping track parameters " << *trackpar);
    return false;
  }
 
  Amg::Transform3D surfTrans;
  surfTrans.setIdentity();
  Trk::CylinderSurface BiggerThanPixelLayerSurface(surfTrans, m_outerRadius, 10000.0);
 
  // extrapolate stepwise to this parameter (be careful, sorting might be wrong)
  std::vector<std::unique_ptr<Trk::TrackParameters>> paramList =
    m_extrapolator->extrapolateStepwise(
      ctx, *trackpar, BiggerThanPixelLayerSurface, Trk::alongMomentum, false);
 
  if (paramList.empty()) {
    ATH_MSG_DEBUG("No parameter returned by propagator ");
    ATH_MSG_VERBOSE("dumping track parameters " << *trackpar);
    return false;
  }
 
  ATH_MSG_DEBUG(
    " Number of generated parameters by propagator: " << paramList.size());
 
  int s_int = 0;
  for (std::unique_ptr<Trk::TrackParameters>& p : paramList) {
    ATH_MSG_DEBUG(s_int++ << "th surface : ");
 
    Identifier id;
    if (!(p->associatedSurface().associatedDetectorElement() != nullptr &&
          p->associatedSurface().associatedDetectorElement()->identify() !=
            0)) {
      continue;
    }
 
    id = p->associatedSurface().associatedDetectorElement()->identify();
    if (!m_idHelper->is_pixel(id)) {
      continue;
    }
 
    ATH_MSG_DEBUG("Found pixel module : " << id.get_compact());
 
    pixelLayerParam.push_back(std::move(p));
  } 
 
  return true;
}

getPixelLayerParameters() [2/2]

bool InDet::InDetTestPixelLayerTool::getPixelLayerParameters ( const Trk::TrackParameters * trackpar, std::vector< std::unique_ptr< const Trk::TrackParameters > > & pixelLayerParam ) const

inlineprivate

Definition at line 101 of file InDetTestPixelLayerTool.h.

  {
    return getPixelLayerParameters(
      Gaudi::Hive::currentContext(), trackpar, pixelLayerParam);
  }

getTrackStateOnInnermostPixelLayerInfo()

bool InDet::IInDetTestPixelLayerTool::getTrackStateOnInnermostPixelLayerInfo ( const Trk::TrackParameters * trackpar, std::vector< TrackStateOnPixelLayerInfo > & infoList ) const

inlineinherited

Definition at line 96 of file IInDetTestPixelLayerTool.h.

  {
    return getTrackStateOnPixelLayerInfo(trackpar, infoList, 0, true);
  }

getTrackStateOnPixelLayerInfo() [1/3]

bool InDet::InDet::InDetTestPixelLayerTool::getTrackStateOnPixelLayerInfo ( const Trk::Track * track, std::vector< TrackStateOnPixelLayerInfo > & infoList ) const

finaloverridevirtual

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 366 of file InDetTestPixelLayerTool.cxx.

{
 
  std::unique_ptr<const Trk::TrackParameters> startParameters = nullptr;
 
  if (track->perigeeParameters()) {
    startParameters = track->perigeeParameters()->uniqueClone();
  } else if (track->trackParameters()->front()) {
    startParameters =
      m_extrapolator->extrapolate(
        Gaudi::Hive::currentContext(),
        *(track->trackParameters()->front()),
        Trk::PerigeeSurface(),
        Trk::anyDirection,
        false);
  }
 
  if (!startParameters) {
    ATH_MSG_WARNING("Found Track with no perigee parameters: no b-layer info "
                    "will be provided");
    return false;
  }
 
  bool succeed = getTrackStateOnPixelLayerInfo(startParameters.get(), infoList);
  return succeed;
}

getTrackStateOnPixelLayerInfo() [2/3]

bool InDet::InDetTestPixelLayerTool::getTrackStateOnPixelLayerInfo ( const Trk::TrackParameters * trackpar, std::vector< TrackStateOnPixelLayerInfo > & infoList, int pixel_layer = -1, bool checkBarrelOnly = false ) const

finaloverridevirtual

pixelLayer param

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 413 of file InDetTestPixelLayerTool.cxx.

{
 
  infoList.clear();
 
  std::vector<std::unique_ptr<const Trk::TrackParameters>> pixelLayerParam;
  if (!getPixelLayerParameters(trackpar, pixelLayerParam))
    return false;
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadHandle<InDet::SiDetectorElementStatus> pixelDetElStatus(getPixelDetElStatus(ctx));
 
  for (std::unique_ptr<const Trk::TrackParameters>& trkParam :
       pixelLayerParam) {
    TrackStateOnPixelLayerInfo pixelLayerInfo;
 
    double fracGood = getFracGood(trkParam.get(),
                                  m_phiRegionSize,
                                  m_etaRegionSize,
                                  !m_pixelDetElStatus.empty() ? pixelDetElStatus.cptr() : nullptr);
    pixelLayerInfo.goodFraction(fracGood);
 
    Identifier id =
      trkParam->associatedSurface().associatedDetectorElement()->identify();
    pixelLayerInfo.moduleId(id);
 
    if (checkBarrelOnly && !m_pixelId->is_barrel(id)) continue;
    if (m_pixelId->layer_disk(id) != pixel_layer) continue;
 
    const auto* tmp = trkParam->associatedSurface().associatedDetectorElement();
    const InDetDD::SiDetectorElement* sielem =
      (tmp != nullptr && tmp->detectorType() == Trk::DetectorElemType::Silicon)
          ? static_cast<const InDetDD::SiDetectorElement*>(tmp)
          : nullptr;
 
    if (!sielem) {
      ATH_MSG_WARNING("Failed to cast TrackParameters associated surface to "
                      "SiDetectorElement");
      return false;
    }
 
    const Amg::Vector2D& locPos = trkParam->localPosition();
    Identifier holeId_c = sielem->identifierOfPosition(locPos);
    pixelLayerInfo.pixelId(holeId_c);
 
    double etaDist = -9999;
    double phiDist = -9999;
    const InDetDD::PixelModuleDesign* design =
      dynamic_cast<const InDetDD::PixelModuleDesign*>(&sielem->design());
    if (design) {
      design->distanceToDetectorEdge(
        locPos,
        etaDist,
        phiDist); 
    } else {
      ATH_MSG_WARNING("could not get pixel module design for  "
                      << m_idHelper->show_to_string(id)
                      << ", returning false for getTrackStateOnPixelLayerInfo");
      return false;
    }
    pixelLayerInfo.distToModuleEdgePhi(phiDist);
    pixelLayerInfo.distToModuleEdgeEta(etaDist);
 
    pixelLayerInfo.globalPosition(trkParam->position());
 
    pixelLayerInfo.localX(locPos[Trk::locX]);
    pixelLayerInfo.localY(locPos[Trk::locY]);
 
    pixelLayerInfo.theta(trkParam->parameters()[Trk::theta]);
    pixelLayerInfo.phi(trkParam->parameters()[Trk::phi0]);
 
    float error_locx = -9999;
    float error_locy = -9999;
 
    if (trkParam->covariance()) {
      error_locx = sqrt((*trkParam->covariance())(Trk::locX, Trk::locX));
      error_locy = sqrt((*trkParam->covariance())(Trk::locY, Trk::locY));
    } else {
      ATH_MSG_DEBUG("could not TrackParameters for hole  "
                    << m_idHelper->show_to_string(id));
    }
 
    pixelLayerInfo.errLocalX(error_locx);
    pixelLayerInfo.errLocalY(error_locy);
 
    VALIDATE_STATUS_ARRAY(
      !m_pixelDetElStatus.empty(),
      pixelDetElStatus->isGood(trkParam->associatedSurface().associatedDetectorElement()->identifyHash()),
      m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx));
    bool isgood =
      ((!m_pixelDetElStatus.empty() &&
        pixelDetElStatus->isGood(trkParam->associatedSurface().associatedDetectorElement()->identifyHash())) ||
       (m_pixelDetElStatus.empty() && m_pixelCondSummaryTool->isGood(id, InDetConditions::PIXEL_MODULE, ctx)));
 
    double phitol = 2.5;
    double etatol = 5.;
 
    if (trkParam->covariance()) {
      phitol = 3 * sqrt((*trkParam->covariance())(Trk::locX, Trk::locX));
      etatol = 3 * sqrt((*trkParam->covariance())(Trk::locY, Trk::locY));
    }
 
    InDetDD::SiIntersect siIn = sielem->inDetector(locPos, phitol, etatol);
    bool isIn = siIn.in();
 
    if (isgood) {
      if (isIn)
        pixelLayerInfo.type(insideGoodModule);
      else
        pixelLayerInfo.type(nearGoodModuleEdge);
    } else {
      if (isIn)
        pixelLayerInfo.type(insideBadModule);
      else
        pixelLayerInfo.type(nearBadModuleEdge);
    }
 
    infoList.push_back(pixelLayerInfo);
  } 
 
  return true;
}

getTrackStateOnPixelLayerInfo() [3/3]

bool InDet::InDetTestPixelLayerTool::getTrackStateOnPixelLayerInfo ( const Trk::TrackParticleBase * track, std::vector< TrackStateOnPixelLayerInfo > & infoList ) const

finaloverridevirtual

Implements InDet::IInDetTestPixelLayerTool.

Definition at line 396 of file InDetTestPixelLayerTool.cxx.

{
 
  const Trk::Perigee* startParameters = track->perigee();
 
  if (!startParameters) {
    ATH_MSG_WARNING("Found TrackParticle with no perigee parameters: no "
                    "b-layer info will be provided");
    return false;
  }
 
  return getTrackStateOnPixelLayerInfo(startParameters, infoList);
}

initialize()

StatusCode InDet::InDetTestPixelLayerTool::initialize ( )

finaloverridevirtual

Definition at line 41 of file InDetTestPixelLayerTool.cxx.

{
 
  // retrieve ID helpers:
  if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
    ATH_MSG_FATAL("Could not get AtlasDetectorID helper");
    return StatusCode::FAILURE;
  }
 
  if (detStore()->retrieve(m_pixelId, "PixelID").isFailure()) {
    ATH_MSG_FATAL("Could not get PixelID helper !");
    return StatusCode::FAILURE;
  }
 
  if (m_extrapolator.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool " << m_extrapolator);
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_pixelCondSummaryTool.retrieve(DisableTool{
    !m_pixelDetElStatus.empty() && !VALIDATE_STATUS_ARRAY_ACTIVATED }));
  ATH_CHECK(m_pixelDetElStatus.initialize(!m_pixelDetElStatus.empty()));
 
  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 & InDet::IInDetTestPixelLayerTool::interfaceID ( )

inlinestaticinherited

Definition at line 32 of file IInDetTestPixelLayerTool.h.

  {
    return IID_IInDetTestPixelLayerTool;
  };

isActive()

bool InDet::InDet::InDetTestPixelLayerTool::isActive ( const Trk::TrackParameters * trackpar ) const

private

checking active material

Definition at line 328 of file InDetTestPixelLayerTool.cxx.

{
 
  const auto* tmp = trackpar->associatedSurface().associatedDetectorElement();
  const InDetDD::SiDetectorElement* siElement =
      (tmp != nullptr && tmp->detectorType() == Trk::DetectorElemType::Silicon)
          ? static_cast<const InDetDD::SiDetectorElement*>(tmp)
          : nullptr;
 
  if (siElement == nullptr) {
    // -------  in dubio pro reo --> return false (is assumed insensitive)
    ATH_MSG_DEBUG("TrackParameters do not belong to a Si Element");
  } else {
    double phitol = 2.5;
    double etatol = 5.;
    if (trackpar->covariance()) {
      phitol = 3. * sqrt((*trackpar->covariance())(Trk::locX, Trk::locX));
      etatol = 3. * sqrt((*trackpar->covariance())(Trk::locY, Trk::locY));
    }
    InDetDD::SiIntersect siIn =
        siElement->inDetector(trackpar->localPosition(), phitol, etatol);
    if (siElement->nearBondGap(trackpar->localPosition(), etatol)) {
      ATH_MSG_DEBUG("---> extrapolation on bond gap within " << etatol
                                                             << ", return");
    } else if (!siIn.in()) {
      ATH_MSG_DEBUG("---> extrapolation not inside (active?) detector within "
                    << phitol << " " << etatol << ", return");
    } else {
      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_checkActiveAreas

BooleanProperty InDet::InDetTestPixelLayerTool::m_checkActiveAreas {this, "CheckActiveAreas", true}

private

Definition at line 145 of file InDetTestPixelLayerTool.h.

{this, "CheckActiveAreas", true};

m_checkDeadRegions

BooleanProperty InDet::InDetTestPixelLayerTool::m_checkDeadRegions {this, "CheckDeadRegions", true}

private

Definition at line 146 of file InDetTestPixelLayerTool.h.

{this, "CheckDeadRegions", true};

m_checkDisabledFEs

BooleanProperty InDet::InDetTestPixelLayerTool::m_checkDisabledFEs {this, "CheckDisabledFEs", true}

private

Definition at line 147 of file InDetTestPixelLayerTool.h.

{this, "CheckDisabledFEs", 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_etaRegionSize

DoubleProperty InDet::InDetTestPixelLayerTool::m_etaRegionSize {this, "EtaRegionSize", 3.}

private

Definition at line 149 of file InDetTestPixelLayerTool.h.

{this, "EtaRegionSize", 3.};

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_extrapolator

ToolHandle<Trk::IExtrapolator> InDet::InDetTestPixelLayerTool::m_extrapolator

private

Initial value:

{
    this,
    "Extrapolator",
    "Trk::Extrapolator/InDetExtrapolator",
    "Extrapolator used to extrapolate to layers"
  }

Pointer to Extrapolator AlgTool.

Definition at line 118 of file InDetTestPixelLayerTool.h.

                                             {
    this,
    "Extrapolator",
    "Trk::Extrapolator/InDetExtrapolator",
    "Extrapolator used to extrapolate to layers"
  };

m_goodFracCut

DoubleProperty InDet::InDetTestPixelLayerTool::m_goodFracCut {this, "GoodFracCut", 0.5}

private

Definition at line 150 of file InDetTestPixelLayerTool.h.

{this, "GoodFracCut", 0.5};

m_idHelper

const AtlasDetectorID* InDet::InDetTestPixelLayerTool::m_idHelper

private

detector helper

Definition at line 140 of file InDetTestPixelLayerTool.h.

m_outerRadius

DoubleProperty InDet::InDetTestPixelLayerTool::m_outerRadius {this, "OuterRadius", 230.}

private

Definition at line 151 of file InDetTestPixelLayerTool.h.

{this, "OuterRadius", 230.};

m_phiRegionSize

DoubleProperty InDet::InDetTestPixelLayerTool::m_phiRegionSize {this, "PhiRegionSize", 3.}

private

Definition at line 148 of file InDetTestPixelLayerTool.h.

{this, "PhiRegionSize", 3.};

m_pixelCondSummaryTool

ToolHandle<IInDetConditionsTool> InDet::InDetTestPixelLayerTool::m_pixelCondSummaryTool

private

Initial value:

{
    this,
    "PixelSummaryTool",
    "PixelConditionsSummaryTool/InDetPixelConditionsSummaryTool",
    "Tool to retrieve Pixel Conditions summary"
  }

Handles to IConditionsSummaryServices for Pixels.

Definition at line 126 of file InDetTestPixelLayerTool.h.

                                                         {
    this,
    "PixelSummaryTool",
    "PixelConditionsSummaryTool/InDetPixelConditionsSummaryTool",
    "Tool to retrieve Pixel Conditions summary"
  };

m_pixelDetElStatus

SG::ReadHandleKey<InDet::SiDetectorElementStatus> InDet::InDetTestPixelLayerTool::m_pixelDetElStatus {this, "PixelDetElStatus", "", "Key of SiDetectorElementStatus for Pixel"}

private

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

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

Definition at line 136 of file InDetTestPixelLayerTool.h.

{this, "PixelDetElStatus", "", "Key of SiDetectorElementStatus for Pixel"};

m_pixelId

const PixelID* InDet::InDetTestPixelLayerTool::m_pixelId

private

ID pixel helper.

Definition at line 143 of file InDetTestPixelLayerTool.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:

• InDetTestPixelLayerTool.h
• InDetTestPixelLayerTool.cxx