SCT_ModuleVetoTool Class Reference

Tool allowing one to manually declare detector elements as 'bad' in the joboptions file. More...

#include <SCT_ModuleVetoTool.h>

Inheritance diagram for SCT_ModuleVetoTool:

Collaboration diagram for SCT_ModuleVetoTool:

Public Member Functions
	SCT_ModuleVetoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SCT_ModuleVetoTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual bool	canReportAbout (InDetConditions::Hierarchy h) const override
	Can the service report about the given component? (chip, module...)
virtual bool	isGood (const Identifier &elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override
	Is the detector element good?
virtual bool	isGood (const Identifier &elementId, const EventContext &ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override
virtual bool	isGood (const IdentifierHash &hashId) const override
	is it good?, using wafer hash
virtual bool	isGood (const IdentifierHash &hashId, const EventContext &ctx) const override
virtual void	getDetectorElementStatus (const EventContext &ctx, InDet::SiDetectorElementStatus &element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override

Private Member Functions
StatusCode	fillData ()
const SCT_ModuleVetoCondData *	getCondData (const EventContext &ctx) const

Private Attributes
StringArrayProperty	m_badElements {this, "BadModuleIdentifiers", {}, "list of bad detector elements (= module sides)"}
SCT_ModuleVetoCondData	m_localCondData {}
const SCT_ID *	m_pHelper {nullptr}
bool	m_useDatabase {false}
StringProperty	m_JsonLocation {this, "JsonPath", "", "Path to the JSON file containing list of modules to be masked."}
BooleanProperty	m_maskLayers {this, "MaskLayers", false, "Mask full layers/disks in overlay"}
IntegerProperty	m_maskSide {this, "MaskSide", -1, "Mask full modules (-1), inner (0) or outer (1) sides"}
IntegerArrayProperty	m_layersToMask {this, "LayersToMask", {}, "Which barrel layers to mask out, goes from 0 to N-1"}
IntegerArrayProperty	m_disksToMask {this, "DisksToMask", {}, "Which endcap disks to mask out, goes from -N+1 to N+1 , skipping zero"}
SG::ReadCondHandleKey< SCT_ModuleVetoCondData >	m_condKey {this, "CondKey", "SCT_ModuleVetoCondData", "SCT modules to be vetoed"}

Detailed Description

Tool allowing one to manually declare detector elements as 'bad' in the joboptions file.

Definition at line 36 of file SCT_ModuleVetoTool.h.

Constructor & Destructor Documentation

SCT_ModuleVetoTool()

SCT_ModuleVetoTool::SCT_ModuleVetoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 32 of file SCT_ModuleVetoTool.cxx.

                                                                                                             :
  base_class(type, name, parent)
{
}

~SCT_ModuleVetoTool()

virtual SCT_ModuleVetoTool::~SCT_ModuleVetoTool ( )

virtualdefault

Member Function Documentation

canReportAbout()

bool SCT_ModuleVetoTool::canReportAbout ( InDetConditions::Hierarchy h ) const

overridevirtual

Can the service report about the given component? (chip, module...)

Definition at line 93 of file SCT_ModuleVetoTool.cxx.

                                                                   {
  return ((h==InDetConditions::DEFAULT) or (h==InDetConditions::SCT_SIDE));
}

fillData()

StatusCode SCT_ModuleVetoTool::fillData ( )

private

Definition at line 164 of file SCT_ModuleVetoTool.cxx.

                             {
  // Reset SCT_ModuleVetoCondData
  m_localCondData.clear();
 
 // @TODO: This part should be changed to use PathResolver before using in production.
 
 //Read bad module IDs from json file.
  if(!m_JsonLocation.empty())
  {
    std::ifstream json_file(m_JsonLocation);
    if (!json_file.is_open()) {
        ATH_MSG_FATAL("Failed to open the json file.");
        return StatusCode::FAILURE;
    }
 
    json data = json::parse(json_file);
 
    for(const auto& i:data)
    {
      std::string id_mod = i["Decimal_ID"];
      unsigned long long id_cstring = std::stoull(id_mod);     
      m_localCondData.setBadWaferId(Identifier(id_cstring));
      ATH_MSG_DEBUG("Masking Module ID: " << id_cstring << ".");
    }
     return StatusCode::SUCCESS;
  }
 
 
  // Fill data based on properties
  StatusCode sc{StatusCode::SUCCESS};
  if ((m_badElements.value().size() - static_cast<int>(m_useDatabase)) == 0 and (not m_maskLayers)) {
    ATH_MSG_INFO("No bad modules in job options.");
    return sc;
  } 
 
 
  bool success{true};
  std::vector<std::string>::const_iterator pId{m_badElements.value().begin()};
  std::vector<std::string>::const_iterator last{m_badElements.value().end()};
  for(; pId not_eq last;++pId) {
    unsigned long long idToWrite{static_cast<unsigned long long>(atoll(pId->c_str()))};
    if (*pId != databaseSignature) success &= m_localCondData.setBadWaferId(Identifier(idToWrite));
  }
 
  
 
  if (m_maskLayers) {
    ATH_MSG_INFO("Masking " << m_layersToMask.size() << " SCT Layers");
    ATH_MSG_INFO("Masking " << m_disksToMask.size() << " SCT Disks");
    for(unsigned int i{0}; i < m_pHelper->wafer_hash_max(); i++) {
      Identifier mID{m_pHelper->wafer_id(i)};
      int bec{m_pHelper->barrel_ec(mID)};
      int side{m_pHelper->side(mID)};
      int layer_disk{m_pHelper->layer_disk(mID)};
 
      if ((bec ==  0 and (m_maskSide==-1 or side==m_maskSide) and (std::find(m_layersToMask.begin(), m_layersToMask.end(),    layer_disk     ) != m_layersToMask.end())) or
          (bec ==  2 and (m_maskSide==-1 or side==m_maskSide) and (std::find(m_disksToMask.begin(),  m_disksToMask.end(),    (layer_disk + 1)) != m_disksToMask.end()))  or
          (bec == -2 and (m_maskSide==-1 or side==m_maskSide) and (std::find(m_disksToMask.begin(),  m_disksToMask.end(), -1*(layer_disk + 1)) != m_disksToMask.end()))) {
        ATH_MSG_DEBUG("Masking ID Hash " << i);
        m_localCondData.setBadWaferId(mID);
      }
    }
  }
  
  ATH_MSG_INFO(m_localCondData.size() << " bad wafers are defined via properties.");
 
  m_localCondData.setFilled();
  ATH_MSG_DEBUG("Successfully filled bad SCT identifiers list");
  return (success ? sc : StatusCode::FAILURE);
}

finalize()

StatusCode SCT_ModuleVetoTool::finalize ( )

overridevirtual

Definition at line 88 of file SCT_ModuleVetoTool.cxx.

                             {
  return StatusCode::SUCCESS;
}

getCondData()

const SCT_ModuleVetoCondData * SCT_ModuleVetoTool::getCondData ( const EventContext & ctx ) const

private

Definition at line 236 of file SCT_ModuleVetoTool.cxx.

                                                             {
  SG::ReadCondHandle<SCT_ModuleVetoCondData> condData{m_condKey, ctx};
  return condData.retrieve();
}

getDetectorElementStatus()

void SCT_ModuleVetoTool::getDetectorElementStatus ( const EventContext & ctx, InDet::SiDetectorElementStatus & element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > * whandle ) const

overridevirtual

Definition at line 135 of file SCT_ModuleVetoTool.cxx.

                                                                                                             {
   std::vector<bool> &status = element_status.getElementStatus();
   if (status.empty()) {
      status.resize(m_pHelper->wafer_hash_max(),true);
   }
   for (const Identifier &wafer_id:  m_localCondData.badWaferIds()) {
      status.at( m_pHelper->wafer_hash(wafer_id) ) = false;
   }
   if (m_useDatabase) {
      SG::ReadCondHandle<SCT_ModuleVetoCondData> condDataHandle{m_condKey, ctx};
      if (not condDataHandle.isValid()) {
         ATH_MSG_ERROR("Failed to get " << m_condKey.key());
         return;
      }
      const SCT_ModuleVetoCondData* condData{ condDataHandle.cptr() };
      if (whandle) {
        whandle->addDependency (condDataHandle);
      }
      if (condData) {
         for (const Identifier &wafer_id: condData->badWaferIds()) {
            status.at( m_pHelper->wafer_hash(wafer_id) ) = false;
         }
      }
   }
}

initialize()

StatusCode SCT_ModuleVetoTool::initialize ( )

overridevirtual

Definition at line 39 of file SCT_ModuleVetoTool.cxx.

                               {
  if (m_maskLayers and m_layersToMask.size()==0 and m_disksToMask.size()==0) {
    ATH_MSG_INFO("Layer/Disk masking enabled, but no layer/disk specified!");
    m_maskLayers = false;
  }
  
  if ((not m_maskLayers) and (m_layersToMask.size() or m_disksToMask.size())) {
    ATH_MSG_INFO("Layer/Disk to mask specified, but masking is disabled!");
  } 
 
  if ((not m_maskLayers) and m_maskSide!=-1) {
    ATH_MSG_INFO("Layer/Disk side to mask specified, but masking is disabled!");
  } 
  
  if (m_maskLayers and m_disksToMask.size() and (std::find(m_disksToMask.begin(), m_disksToMask.end(),0)!=m_disksToMask.end())) {
    ATH_MSG_WARNING("0th Disk not defined (-N to N) - check your setup!");
  }   
 
  if (detStore()->retrieve(m_pHelper, "SCT_ID").isFailure()) {
    ATH_MSG_FATAL("SCT helper failed to retrieve");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO("Successfully retrieved SCT_ID helper");
  }
 
  // If "database" is found in m_badElements, COOL database is used.
  m_useDatabase=(std::find(m_badElements.value().begin(), m_badElements.value().end(), databaseSignature) != m_badElements.value().end());
  ATH_MSG_INFO("m_useDatabase is " << m_useDatabase);
 
  if (not m_useDatabase) {
    if (fillData().isFailure()) {
      ATH_MSG_FATAL("Failed to fill data");
      return StatusCode::FAILURE;
    }
  }
 
  // Read Cond Handle
  ATH_CHECK(m_condKey.initialize(m_useDatabase));
 
  const std::string databaseUseString{m_useDatabase ? "" : "not "};
  ATH_MSG_INFO("Initialized veto service with data, "
               << (m_badElements.value().size() - static_cast<long unsigned int>(m_useDatabase))
               << " elements declared bad. Database will " << databaseUseString << "be used.");
 
  return StatusCode::SUCCESS;
}

isGood() [1/4]

bool SCT_ModuleVetoTool::isGood ( const Identifier & elementId, const EventContext & ctx, InDetConditions::Hierarchy h = InDetConditions::DEFAULT ) const

overridevirtual

Definition at line 98 of file SCT_ModuleVetoTool.cxx.

                                                                                                                 {
  if (not canReportAbout(h)) return true;
 
  const Identifier waferId{m_pHelper->wafer_id(elementId)};
 
  // Bad wafer in properties
  if (m_localCondData.isBadWaferId(waferId)) return false;
  // If database is not used, all wafer IDs here should be good.
  if (not m_useDatabase) return true;
 
  const SCT_ModuleVetoCondData* condData{getCondData(ctx)};
  // If database cannot be retrieved, all wafer IDs are good.
  if (condData==nullptr) return true;
 
  // Return the result of database
  return (not condData->isBadWaferId(waferId));
}

isGood() [2/4]

bool SCT_ModuleVetoTool::isGood ( const Identifier & elementId, InDetConditions::Hierarchy h = InDetConditions::DEFAULT ) const

overridevirtual

Is the detector element good?

Definition at line 117 of file SCT_ModuleVetoTool.cxx.

                                                                                        {
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  return isGood(elementId, ctx, h);
}

isGood() [3/4]

bool SCT_ModuleVetoTool::isGood ( const IdentifierHash & hashId ) const

overridevirtual

is it good?, using wafer hash

Definition at line 129 of file SCT_ModuleVetoTool.cxx.

                                                             {
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  return isGood(hashId, ctx);
}

isGood() [4/4]

bool SCT_ModuleVetoTool::isGood ( const IdentifierHash & hashId, const EventContext & ctx ) const

overridevirtual

Definition at line 123 of file SCT_ModuleVetoTool.cxx.

                                                                                      {
  Identifier elementId{m_pHelper->wafer_id(hashId)};
  return isGood(elementId, ctx, InDetConditions::SCT_SIDE);
}

Member Data Documentation

m_badElements

StringArrayProperty SCT_ModuleVetoTool::m_badElements {this, "BadModuleIdentifiers", {}, "list of bad detector elements (= module sides)"}

private

Definition at line 60 of file SCT_ModuleVetoTool.h.

{this, "BadModuleIdentifiers", {}, "list of bad detector elements (= module sides)"};

m_condKey

SG::ReadCondHandleKey<SCT_ModuleVetoCondData> SCT_ModuleVetoTool::m_condKey {this, "CondKey", "SCT_ModuleVetoCondData", "SCT modules to be vetoed"}

private

Definition at line 71 of file SCT_ModuleVetoTool.h.

{this, "CondKey", "SCT_ModuleVetoCondData", "SCT modules to be vetoed"};

m_disksToMask

IntegerArrayProperty SCT_ModuleVetoTool::m_disksToMask {this, "DisksToMask", {}, "Which endcap disks to mask out, goes from -N+1 to N+1 , skipping zero"}

private

Definition at line 68 of file SCT_ModuleVetoTool.h.

{this, "DisksToMask", {}, "Which endcap disks to mask out, goes from -N+1 to N+1 , skipping zero"}; 

m_JsonLocation

StringProperty SCT_ModuleVetoTool::m_JsonLocation {this, "JsonPath", "", "Path to the JSON file containing list of modules to be masked."}

private

Definition at line 64 of file SCT_ModuleVetoTool.h.

{this, "JsonPath", "", "Path to the JSON file containing list of modules to be masked."};

m_layersToMask

IntegerArrayProperty SCT_ModuleVetoTool::m_layersToMask {this, "LayersToMask", {}, "Which barrel layers to mask out, goes from 0 to N-1"}

private

Definition at line 67 of file SCT_ModuleVetoTool.h.

{this, "LayersToMask", {}, "Which barrel layers to mask out, goes from 0 to N-1"};

m_localCondData

SCT_ModuleVetoCondData SCT_ModuleVetoTool::m_localCondData {}

private

Definition at line 61 of file SCT_ModuleVetoTool.h.

{};

m_maskLayers

BooleanProperty SCT_ModuleVetoTool::m_maskLayers {this, "MaskLayers", false, "Mask full layers/disks in overlay"}

private

Definition at line 65 of file SCT_ModuleVetoTool.h.

{this, "MaskLayers", false, "Mask full layers/disks in overlay"};

m_maskSide

IntegerProperty SCT_ModuleVetoTool::m_maskSide {this, "MaskSide", -1, "Mask full modules (-1), inner (0) or outer (1) sides"}

private

Definition at line 66 of file SCT_ModuleVetoTool.h.

{this, "MaskSide", -1, "Mask full modules (-1), inner (0) or outer (1) sides"};

m_pHelper

const SCT_ID* SCT_ModuleVetoTool::m_pHelper {nullptr}

private

Definition at line 62 of file SCT_ModuleVetoTool.h.

{nullptr};

m_useDatabase

bool SCT_ModuleVetoTool::m_useDatabase {false}

private

Definition at line 63 of file SCT_ModuleVetoTool.h.

{false};

---

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

• SCT_ModuleVetoTool.h
• SCT_ModuleVetoTool.cxx