ElectronSelectorHelpers Namespace Reference

Functions
std::size_t	numberOfPixelHitsAndDeadSensors (const xAOD::TrackParticle &tp)
	return the number of Pixel hits plus dead sensors in the track particle
std::size_t	numberOfSCTHitsAndDeadSensors (const xAOD::TrackParticle &tp)
	return the number of SCT hits plus dead sensors in the track particle
std::size_t	numberOfSiliconHitsAndDeadSensors (const xAOD::TrackParticle &tp)
	return the number of Silicon hits plus dead sensors in the track particle
bool	passBLayerRequirement (const xAOD::TrackParticle &tp)
	return true if effective number of BL hits + outliers is at least one
bool	passAmbiguity (xAOD::AmbiguityTool::AmbiguityType type, const uint16_t criterion)
	return true if the ambiguity type is one of several that are stored in a bitmask

Function Documentation

numberOfPixelHitsAndDeadSensors()

std::size_t ElectronSelectorHelpers::numberOfPixelHitsAndDeadSensors

(

const xAOD::TrackParticle &

tp

)

return the number of Pixel hits plus dead sensors in the track particle

Definition at line 12 of file ElectronSelectorHelpers.cxx.

{
 
  uint8_t nPixHits(0);
  uint8_t nPixDead(0);
 
  bool allFound = true;
  allFound = allFound && tp.summaryValue(nPixHits, xAOD::numberOfPixelHits);
  allFound =
    allFound && tp.summaryValue(nPixDead, xAOD::numberOfPixelDeadSensors);
  if (!allFound) {
    throw std::runtime_error(
      "numberOfPixelHitsAndDeadSensors : Failed to load variables");
  }
 
  return nPixHits + nPixDead;
}

numberOfSCTHitsAndDeadSensors()

std::size_t ElectronSelectorHelpers::numberOfSCTHitsAndDeadSensors

(

const xAOD::TrackParticle &

tp

)

return the number of SCT hits plus dead sensors in the track particle

Definition at line 32 of file ElectronSelectorHelpers.cxx.

{
  uint8_t nSCTHits(0);
  uint8_t nSCTDead(0);
 
  bool allFound = true;
  allFound = allFound && tp.summaryValue(nSCTHits, xAOD::numberOfSCTHits);
  allFound =
    allFound && tp.summaryValue(nSCTDead, xAOD::numberOfSCTDeadSensors);
  if (!allFound) {
    throw std::runtime_error(
      "numberOfSCTHitsAndDeadSensors : Failed to load variables");
  }
 
  return nSCTHits + nSCTDead;
}

numberOfSiliconHitsAndDeadSensors()

std::size_t ElectronSelectorHelpers::numberOfSiliconHitsAndDeadSensors

(

const xAOD::TrackParticle &

tp

)

return the number of Silicon hits plus dead sensors in the track particle

Definition at line 51 of file ElectronSelectorHelpers.cxx.

{
  return numberOfPixelHitsAndDeadSensors(tp) +
         numberOfSCTHitsAndDeadSensors(tp);
}

passAmbiguity()

bool ElectronSelectorHelpers::passAmbiguity	(	xAOD::AmbiguityTool::AmbiguityType	type,
		const uint16_t	criterion )

return true if the ambiguity type is one of several that are stored in a bitmask

Definition at line 104 of file ElectronSelectorHelpers.cxx.

{
 
  // helper to check if ambiguity type is one of several that are stored in a
  // bitmask
  //
  return (criterion & 0x1 << type);
}

passBLayerRequirement()

bool ElectronSelectorHelpers::passBLayerRequirement

(

const xAOD::TrackParticle &

tp

)

return true if effective number of BL hits + outliers is at least one

Definition at line 59 of file ElectronSelectorHelpers.cxx.

{
 
  uint8_t expectInnermostLayer(0);
  uint8_t nInnermostLayerHits(0);
  uint8_t nInnermostLayerOutliers(0);
  uint8_t expectNextToInnermostLayer(0);
  uint8_t nNextToInnermostLayerHits(0);
  uint8_t nNextToInnermostLayerOutliers(0);
 
  bool allFound = true;
  allFound =
    allFound && tp.summaryValue(expectInnermostLayer, xAOD::expectBLayerHit);
  allFound =
    allFound && tp.summaryValue(nInnermostLayerHits, xAOD::numberOfBLayerHits);
  allFound = allFound && tp.summaryValue(nInnermostLayerOutliers,
                                         xAOD::numberOfBLayerOutliers);
  allFound =
    allFound && tp.summaryValue(expectNextToInnermostLayer,
                                xAOD::expectNextToInnermostPixelLayerHit);
  allFound =
    allFound && tp.summaryValue(nNextToInnermostLayerHits,
                                xAOD::numberOfNextToInnermostPixelLayerHits);
  allFound = allFound &&
             tp.summaryValue(nNextToInnermostLayerOutliers,
                             xAOD::numberOfNextToInnermostPixelLayerOutliers);
  if (!allFound) {
    throw std::runtime_error(
      "passBLayerRequirement : Failed to load variables");
  }
 
  // If innermost and next to innermost layer are both masked off, then the
  // selectors should PASS the BL cut, so the default here is true
  bool passBLReq = true;
 
  if (expectInnermostLayer) {
    passBLReq = (nInnermostLayerHits + nInnermostLayerOutliers > 0);
  } else if (expectNextToInnermostLayer) {
    passBLReq = (nNextToInnermostLayerHits + nNextToInnermostLayerOutliers > 0);
  }
 
  return passBLReq;
}