LArNoisyROTool Class Reference

#include <LArNoisyROTool.h>

Inheritance diagram for LArNoisyROTool:

Collaboration diagram for LArNoisyROTool:

Classes
class	FEBEvtStat
struct	HVlinesStatMapValue

Public Member Functions
virtual	~LArNoisyROTool ()=default
	Destructor:
virtual StatusCode	initialize ()
virtual std::unique_ptr< LArNoisyROSummary >	process (const EventContext &, const CaloCellContainer *, const std::set< unsigned int > *, const std::vector< HWIdentifier > *, const LArHVNMap *, const CaloDetDescrManager *, const LArHVIdMapping *) const

Private Types
typedef std::unordered_map< unsigned int, FEBEvtStat >	FEBEvtStatMap
typedef std::unordered_map< HWIdentifier, HVlinesStatMapValue >	HVlinesStatMap

Private Member Functions
size_t	partitionNumber (const HWIdentifier) const

Private Attributes
std::unordered_map< unsigned int, unsigned int >	m_mapPSFEB
ToolHandle< ILArHVMapTool >	m_hvMapTool {"LArHVMapTool"}
const CaloCell_ID *	m_calo_id = nullptr
const LArOnlineID *	m_onlineID = nullptr
const LArElectrodeID *	m_elecID = nullptr
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this, "CablingKey", "LArOnOffIdMap", "key to read OnOff mapping"}
Gaudi::Property< unsigned int >	m_CellQualityCut {this, "CellQualityCut", 4000, "Qfactor value above which a channel is considered bad"}
Gaudi::Property< bool >	m_ignore_masked_cells {this, "IgnoreMaskedCells", false, "ignore masked cells"}
Gaudi::Property< bool >	m_ignore_front_innerwheel_cells {this, "IgnoreFrontInnerWheelCells", true, "ignore front inner wheel cells ?"}
Gaudi::Property< unsigned int >	m_BadChanPerFEB {this, "BadChanPerFEB", 30, "number of bad channels to declare a FEB noisy"}
Gaudi::Property< unsigned int >	m_MinBadFEB {this, "BadFEBCut", 3, "min number of bad FEB to put LAr warning in event info"}
Gaudi::Property< unsigned int >	m_SaturatedCellQualityCut
Gaudi::Property< float >	m_SaturatedCellEnergyTightCut
Gaudi::Property< unsigned int >	m_SaturatedCellTightCut {this, "SaturatedCellTightCut", 20, "min number of saturated Qfactor cells to declare an event bad"}
Gaudi::Property< bool >	m_doHVline {this, "DoHVflag", true, "do HVline flagging"}
Gaudi::Property< float >	m_BadChanFracPerHVline {this, "BadChanFracPerHVline", 0.25, "min fraction of bad cells in one HV line"}
Gaudi::Property< unsigned int >	m_MinBadHV {this, "BadHVCut", 3, " min number of bad HV lines"}
Gaudi::Property< unsigned int >	m_connChanPerHVline {this, "ConnectedChanPerHVline", 10, "min number of cells connected to HV line for it to be used for HV flag"}
Gaudi::Property< unsigned int >	m_MNBLooseCut {this, "MNBLooseCut", 5, "Loose cut on number of cells above CellQualityCut"}
Gaudi::Property< unsigned int >	m_MNBTightCut {this, "MNBTightCut", 17, "Thight cut on number of cells above CellQualityCut"}
Gaudi::Property< std::vector< unsigned int > >	m_MNBTight_PsVetoCut {this, "MNBTight_PsVetoCut", {13, 3}}
std::array< uint8_t, 4 >	m_partitionMask

Detailed Description

Definition at line 40 of file LArNoisyROTool.h.

Member Typedef Documentation

FEBEvtStatMap

typedef std::unordered_map<unsigned int, FEBEvtStat> LArNoisyROTool::FEBEvtStatMap

private

Definition at line 84 of file LArNoisyROTool.h.

HVlinesStatMap

typedef std::unordered_map<HWIdentifier, HVlinesStatMapValue> LArNoisyROTool::HVlinesStatMap

private

Definition at line 92 of file LArNoisyROTool.h.

Constructor & Destructor Documentation

~LArNoisyROTool()

virtual LArNoisyROTool::~LArNoisyROTool ( )

virtualdefault

Destructor:

Member Function Documentation

initialize()

StatusCode LArNoisyROTool::initialize ( )

virtual

Definition at line 22 of file LArNoisyROTool.cxx.

                                      {
 
  if ( m_CellQualityCut > m_SaturatedCellQualityCut ) {
    ATH_MSG_FATAL( "Configuration problem: LArNoisyROTool assumes that the QFactor cut to declare a channel noisy is softer than the QFactor cut to declare the quality saturated !"  );
    return StatusCode::FAILURE;
  }
 
  if ( m_MNBLooseCut > m_MNBTightCut) {
    ATH_MSG_FATAL( "Configuration problem: LArNoisyROTool assumes that MNBLooseCut is smaller than MNBTightCut"  );
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
  ATH_CHECK(detStore()->retrieve(m_onlineID,"LArOnlineID"));
  ATH_CHECK(detStore()->retrieve(m_elecID,"LArElectrodeID"));
  ATH_CHECK( m_cablingKey.initialize() );
 
  // Fill the map between any EMB FEB and the same FT PS FEB
  // Filled only for EMB so far
  for (std::vector<HWIdentifier>::const_iterator allFeb = m_onlineID->feb_begin(); 
       allFeb != m_onlineID->feb_end(); ++allFeb) {
    
    HWIdentifier febid = HWIdentifier(*allFeb);    
    int FEBIndex = febid.get_identifier32().get_compact();
    int FEBIndex_PS = 0;
    int barrel_ec = m_onlineID->barrel_ec(febid);
    if (barrel_ec == 0){
      int pos_neg   = m_onlineID->pos_neg(febid);
      int ft        = m_onlineID->feedthrough(febid);
      FEBIndex_PS = (m_onlineID->feb_Id(0,pos_neg,ft,1)).get_identifier32().get_compact();      
    }
    m_mapPSFEB[FEBIndex] = FEBIndex_PS;
  }
 
  return StatusCode::SUCCESS;
}

partitionNumber()

size_t LArNoisyROTool::partitionNumber ( const HWIdentifier hwid ) const

inlineprivate

Definition at line 135 of file LArNoisyROTool.h.

                                                                           {
  int pn=m_onlineID->pos_neg(hwid);
 
  if (m_onlineID->isEMECchannel(hwid)) {
    if (pn)
      return 0;  // positive EMECA side
    else
      return 3;  // negative EMECC side
  }
  if (m_onlineID->isEMBchannel(hwid)) {
    if (pn)
      return 1;  // positive EMBA side
    else
      return 2;  // negative EMBC side
  }
  return 4;//Anything else
}

process()

std::unique_ptr< LArNoisyROSummary > LArNoisyROTool::process ( const EventContext & ctx, const CaloCellContainer * cellContainer, const std::set< unsigned int > * knownBadFEBs, const std::vector< HWIdentifier > * knownMNBFEBs, const LArHVNMap * nCellsperLine, const CaloDetDescrManager * cddm, const LArHVIdMapping * hvid ) const

virtual

Definition at line 60 of file LArNoisyROTool.cxx.

                                                                                                                                                                                                                                                                                                                 {
 
  // sanity check
  bool doHVline=m_doHVline;
  if(doHVline && ( !nCellsperLine || !cddm || !hvid)) {
     ATH_MSG_ERROR("HV line flagging asked, but missing ingrediences, switching off !!");
     doHVline = false;
  }
 
  std::unique_ptr<LArNoisyROSummary> noisyRO=std::make_unique<LArNoisyROSummary>();
 
  if(!cellContainer) return noisyRO;
 
  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl(m_cablingKey, ctx);
  const LArOnOffIdMapping* cabling=*larCablingHdl;
  
  FEBEvtStatMap FEBStats; //counter per FEB
  HVlinesStatMap HVStats; //counter per HV line
 
  unsigned int NsaturatedTightCutBarrelA = 0;
  unsigned int NsaturatedTightCutBarrelC = 0;
  unsigned int NsaturatedTightCutEMECA = 0;
  unsigned int NsaturatedTightCutEMECC = 0;
 
  for (const CaloCell* cell : *cellContainer )
  {
    if (!cell) continue;
 
    // only cells with a bad enough Quality Factor
    if ( cell->quality() < m_CellQualityCut ) continue;
 
    // cells with zero energy have been masked by previous algorithms
    // they should not matter for physics so don't consider them
    if ( m_ignore_masked_cells && std::abs(cell->e()) < 0.1 ) continue; //Fixme: use provenance
 
    Identifier id = cell->ID();
    if (m_ignore_front_innerwheel_cells && m_calo_id->is_em_endcap_inner(id) && m_calo_id->sampling(id) == 1) continue; // Front inner wheel cells are ignored
 
    // saturated Qfactor ? Tight cuts.
    if ( cell->quality()>=m_SaturatedCellQualityCut && 
     std::abs(cell->e()) > m_SaturatedCellEnergyTightCut )
    {
      bool sideA = cell->eta() > 0.;
      if ( m_calo_id->is_em_barrel(id) )
      {
    if ( sideA ) { NsaturatedTightCutBarrelA++; } 
    else { NsaturatedTightCutBarrelC++; }
      }
      else if ( m_calo_id->is_em_endcap(id) )
      {
    if ( sideA ) { NsaturatedTightCutEMECA++; } 
    else { NsaturatedTightCutEMECC++; }
      }
    }
 
 
    // only LAr EM for bad FEBs
    if ( m_calo_id->is_em(id) ) 
    {
      // get FEB ID and channel number
      HWIdentifier hwid = cabling->createSignalChannelID(id);
      HWIdentifier febid = m_onlineID->feb_Id(hwid);
      unsigned int FEBindex = febid.get_identifier32().get_compact();
      unsigned int channel = m_onlineID->channel(hwid);    
      FEBStats[FEBindex].addBadChannel(channel);
    }
 
    if (doHVline) {
       //HVline, in all calos
       std::vector<HWIdentifier> hvlines;
       m_hvMapTool->GetHVLines(id, cddm,hvlines);
       for (unsigned int i=0; i<hvlines.size(); ++i) {
         auto& stats = HVStats[hvlines[i]];
         stats.noisy += 1;
         stats.sharedNoisy += static_cast<uint32_t>(hvlines.size());
       }
    }
  }
 
  // Store the Saturated flag per partition
  uint8_t SatTightPartitions = 0;
  if ( NsaturatedTightCutBarrelA >= m_SaturatedCellTightCut ) SatTightPartitions |= LArNoisyROSummary::EMBAMask;
  if ( NsaturatedTightCutBarrelC >= m_SaturatedCellTightCut ) SatTightPartitions |= LArNoisyROSummary::EMBCMask;
  if ( NsaturatedTightCutEMECA >= m_SaturatedCellTightCut ) SatTightPartitions |= LArNoisyROSummary::EMECAMask;
  if ( NsaturatedTightCutEMECC >= m_SaturatedCellTightCut ) SatTightPartitions |= LArNoisyROSummary::EMECCMask;
  bool badSaturatedTightCut = (SatTightPartitions != 0);
  if ( badSaturatedTightCut ) noisyRO-> SetSatTightFlaggedPartitions(SatTightPartitions);
 
  // loop on all FEBs and check whether FEB can be declared as bad for the different type of flags:
  // regular noise burst, weighted noise burst, MNB tight and loose
  for (auto& it : FEBStats) {
    ATH_MSG_VERBOSE(" candidate FEB " << it.first << " with " << it.second.badChannels() << " bad channels");
    if ( it.second.badChannels() > m_BadChanPerFEB ) {
      noisyRO->add_noisy_feb(HWIdentifier(it.first));
    }
 
    // Loose MNBs
    if ( it.second.badChannels() > m_MNBLooseCut ){
       noisyRO->add_MNBLoose_feb(HWIdentifier(it.first));
       ATH_MSG_DEBUG("Loose bad FEB " << it.first << " " << m_onlineID->channel_name(HWIdentifier(it.first)) << " with " << it.second.badChannels() << " bad channels");
       // Tight_PsVeto MNBs
       if ( it.second.badChannels() > m_MNBTight_PsVetoCut[0] ){
         unsigned int associatedPSFEB = 0;
         auto assoc_it = m_mapPSFEB.find(it.first);
         if (assoc_it != m_mapPSFEB.end()) {
           associatedPSFEB = assoc_it->second;
         }
         if (associatedPSFEB != 0){ // Check if a PS FEB is associated (TRUE only for EMB FEBs)
           if (FEBStats.count(associatedPSFEB) == 0) noisyRO->add_MNBTight_PsVeto_feb(HWIdentifier(it.first));
           else if (FEBStats[associatedPSFEB].badChannels() < m_MNBTight_PsVetoCut[1]) noisyRO->add_MNBTight_PsVeto_feb(HWIdentifier(it.first));
         }
       }
       // Tight MNBs
       if ( it.second.badChannels() > m_MNBTightCut ){
          noisyRO->add_MNBTight_feb(HWIdentifier(it.first));
       }
    }
 
  }//end loop over m_FEBats
 
 
  // Count noisy FEB per partition EMEC-EMB - Simple and weighted quantities
  unsigned int NBadFEBEMECA = 0; unsigned int NBadFEBEMECA_W = 0;
  unsigned int NBadFEBEMECC = 0; unsigned int NBadFEBEMECC_W = 0;
  unsigned int NBadFEBEMBA = 0; unsigned int NBadFEBEMBA_W = 0;
  unsigned int NBadFEBEMBC = 0; unsigned int NBadFEBEMBC_W = 0;
 
  const std::vector<HWIdentifier>& badfebs = noisyRO->get_noisy_febs();
  
  //for ( std::vector<HWIdentifier>::const_iterator febit = badfebs.begin();
  //    febit != badfebs.end(); febit++ )
  for (const HWIdentifier& febid : badfebs) 
  {
    // first channel of FEB, as safety since FEBid seem to be the Id of the
    // first channel (no guarantee?)
    HWIdentifier chanID = m_onlineID->channel_Id(febid,0);
 
    int weight = 1;
    // If the FEB is known to be subject to noise burst (list defiend as property)
    // give a weight 2
    const unsigned int int_id =  febid.get_identifier32().get_compact();
    if (knownBadFEBs->find(int_id)!=knownBadFEBs->end()) weight=2;
 
    if ( m_onlineID->isEMBchannel(chanID) ) 
    {
      if ( m_onlineID->pos_neg(chanID) == 1 ){
      NBadFEBEMBA_W = NBadFEBEMBA_W + weight;
      NBadFEBEMBA++;
      }
      else{
    NBadFEBEMBC_W = NBadFEBEMBC_W + weight;
    NBadFEBEMBC++;
      }
    }
    else if ( m_onlineID->isEMECchannel(chanID) ) 
    {
      if ( m_onlineID->pos_neg(chanID) == 1 ){
    NBadFEBEMECA_W = NBadFEBEMECA_W + weight;
    NBadFEBEMECA++;
      }
      else{
    NBadFEBEMECC_W = NBadFEBEMECC_W + weight;
    NBadFEBEMECC++;
      }
    }
  } 
 
  uint8_t BadFEBPartitions = 0;
  if ( NBadFEBEMBA  > m_MinBadFEB )  BadFEBPartitions |= LArNoisyROSummary::EMBAMask;
  if ( NBadFEBEMBC  > m_MinBadFEB )  BadFEBPartitions |= LArNoisyROSummary::EMBCMask;
  if ( NBadFEBEMECA  > m_MinBadFEB )  BadFEBPartitions |= LArNoisyROSummary::EMECAMask;
  if ( NBadFEBEMECC  > m_MinBadFEB )  BadFEBPartitions |= LArNoisyROSummary::EMECCMask;
  if ( BadFEBPartitions != 0  ) noisyRO-> SetBadFEBFlaggedPartitions(BadFEBPartitions);
 
  uint8_t BadFEBPartitions_W = 0;
  if ( NBadFEBEMBA_W  > m_MinBadFEB )  BadFEBPartitions_W |= LArNoisyROSummary::EMBAMask;
  if ( NBadFEBEMBC_W  > m_MinBadFEB )  BadFEBPartitions_W |= LArNoisyROSummary::EMBCMask;
  if ( NBadFEBEMECA_W  > m_MinBadFEB )  BadFEBPartitions_W |= LArNoisyROSummary::EMECAMask;
  if ( NBadFEBEMECC_W  > m_MinBadFEB )  BadFEBPartitions_W |= LArNoisyROSummary::EMECCMask;
  if ( BadFEBPartitions_W != 0 ) noisyRO-> SetBadFEB_WFlaggedPartitions(BadFEBPartitions_W);
 
 
 
  //Check for Mini Noise Bursts:
  uint8_t MNBTightPartition=0;
  uint8_t MNBTight_PsVetoPartition=0;
  uint8_t MNBLoosePartition=0;
  
  std::array<unsigned,5> nTightMNBFEBSperPartition{};
  std::array<unsigned,5> nTight_PsVetoMNBFEBSperPartition{};
  std::array<unsigned,5> nLooseMNBFEBSperPartition{};
  for (HWIdentifier febid: *knownMNBFEBs) { //Loop over known MNB FEBs
    auto statIt=FEBStats.find(febid.get_identifier32().get_compact());
    if (statIt!=FEBStats.end()) {
      if (statIt->second.badChannels()>=m_MNBLooseCut) {
          (nLooseMNBFEBSperPartition[partitionNumber(febid)])++;
        // Tight_PsVeto MNBs
          if ( statIt->second.badChannels() > m_MNBTight_PsVetoCut[0] ){
            auto found = m_mapPSFEB.find(statIt->first);
            if (found != m_mapPSFEB.end()){
              if (unsigned int associatedPSFEB = found->second; associatedPSFEB != 0){
                if (FEBStats.count(associatedPSFEB) == 0) (nTight_PsVetoMNBFEBSperPartition[partitionNumber(febid)])++;
                else if (FEBStats[associatedPSFEB].badChannels() < m_MNBTight_PsVetoCut[1]) (nTight_PsVetoMNBFEBSperPartition[partitionNumber(febid)])++;
              }
            }
          }
        // Tight MNBs
        if (statIt->second.badChannels()>=m_MNBTightCut)
          (nTightMNBFEBSperPartition[partitionNumber(febid)])++;
      }
    }//End FEB in list of bad-Q FEBs
  }//end loop over known MNB Febs
 
 
  for (unsigned iP=0;iP<4;++iP) {
    ATH_MSG_DEBUG( "Partition " << iP << ": Found " << nLooseMNBFEBSperPartition[iP] << " MNB FEBs with more than " <<  m_MNBLooseCut << " bad-Q channels"  );
    ATH_MSG_DEBUG( "Partition " << iP << ": Found " << nTightMNBFEBSperPartition[iP] << " MNB FEBs with more than " <<  m_MNBTightCut << " bad-Q channels"  );
    if (nLooseMNBFEBSperPartition[iP]>0) MNBLoosePartition |= m_partitionMask[iP];
    if (nTightMNBFEBSperPartition[iP]>0) MNBTightPartition |= m_partitionMask[iP];
    if (nTight_PsVetoMNBFEBSperPartition[iP]>0) MNBTight_PsVetoPartition |= m_partitionMask[iP];
  }// end loop over partitions      
 
 
  noisyRO->SetMNBTightFlaggedPartitions(MNBTightPartition);
  noisyRO->SetMNBTight_PsVetoFlaggedPartitions(MNBTight_PsVetoPartition);
  noisyRO->SetMNBLooseFlaggedPartitions(MNBLoosePartition);
 
  if(!hvid || !nCellsperLine ) return noisyRO; // do not have HVcells map
 
  // Count noisy HVlines per partition
  float NBadHVEMECA = 0;
  float NBadHVEMECC = 0;
  float NBadHVEMBA = 0; 
  float NBadHVEMBC = 0; 
  float NBadHVHECA = 0; 
  float NBadHVHECC = 0; 
  float NBadHVFCALA = 0; 
  float NBadHVFCALC = 0; 
  // loop over HVlines, to check if they are qualified as noisy
  for ( HVlinesStatMap::const_iterator it = HVStats.begin(); it != HVStats.end(); ++it ) {
    ATH_MSG_DEBUG(ctx.eventID().event_number()<<" candidate HVline " << it->first << " with " << it->second.noisy << " bad channels, out of "<<nCellsperLine->HVNcell(HWIdentifier(it->first))<<" channels");
    short nCells = nCellsperLine->HVNcell(it->first);
    if ( it->second.noisy >= m_BadChanFracPerHVline * nCells && nCells >= static_cast<short>(m_connChanPerHVline)) {
      HWIdentifier hwd(it->first); 
      noisyRO->add_noisy_hvline(hwd);
      const std::vector<HWIdentifier> elecVec = hvid->getLArElectrodeIDvec(hwd);
      int side = m_elecID->zside(elecVec[0]);
      int part = m_elecID->detector(elecVec[0]);
      const float w = float(it->second.noisy) / it->second.sharedNoisy;
      switch(side) {
         case 1: { ATH_MSG_DEBUG("Elec. side: "<<side);
                    switch(part){
                    case 0: case 1:{NBadHVEMBC += w; break;}
                    case 2: case 3:{NBadHVEMECC += w; break;}
                    case 4:        {NBadHVHECC += w; break;}
                    case 5:        {NBadHVFCALC += w; break;}
                    default:       {ATH_MSG_WARNING("Wrong HV line detector "<<part); break;}
                   };
                   break; 
                 }
         case 0: { switch(part){
                    case 0: case 1:{NBadHVEMBA += w; break;}
                    case 2: case 3:{NBadHVEMECA += w; break;}
                    case 4:        {NBadHVHECA += w; break;}
                    case 5:        {NBadHVFCALA += w; break;}
                    default:       {ATH_MSG_WARNING("Wrong HV line detector "<<part); break;}
                   };
                   break;               
                 }
      }
    }// HVline is noisy
  }// all hvlines 
 
  uint8_t BadHVPartitions = 0;
  if ( NBadHVEMBA  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::EMBAMask;
  if ( NBadHVEMBC  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::EMBCMask;
  if ( NBadHVEMECA  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::EMECAMask;
  if ( NBadHVEMECC  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::EMECCMask;
  if ( NBadHVHECA  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::HECAMask;
  if ( NBadHVHECC  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::HECCMask;
  if ( NBadHVFCALA  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::FCALAMask;
  if ( NBadHVFCALC  >= m_MinBadHV )  BadHVPartitions |= LArNoisyROSummary::FCALCMask;
 
  if ( BadHVPartitions != 0 ) noisyRO-> SetBadHVlinesPartitions(BadHVPartitions);
 
  return noisyRO;
}

Member Data Documentation

m_BadChanFracPerHVline

Gaudi::Property<float> LArNoisyROTool::m_BadChanFracPerHVline {this, "BadChanFracPerHVline", 0.25, "min fraction of bad cells in one HV line"}

private

Definition at line 122 of file LArNoisyROTool.h.

{this, "BadChanFracPerHVline", 0.25, "min fraction of bad cells in one HV line"};

m_BadChanPerFEB

Gaudi::Property<unsigned int> LArNoisyROTool::m_BadChanPerFEB {this, "BadChanPerFEB", 30, "number of bad channels to declare a FEB noisy"}

private

Definition at line 108 of file LArNoisyROTool.h.

{this, "BadChanPerFEB", 30, "number of bad channels to declare a FEB noisy"};

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArNoisyROTool::m_cablingKey {this, "CablingKey", "LArOnOffIdMap", "key to read OnOff mapping"}

private

Definition at line 100 of file LArNoisyROTool.h.

{this, "CablingKey", "LArOnOffIdMap", "key to read OnOff mapping"};

m_calo_id

const CaloCell_ID* LArNoisyROTool::m_calo_id = nullptr

private

Definition at line 97 of file LArNoisyROTool.h.

m_CellQualityCut

Gaudi::Property<unsigned int> LArNoisyROTool::m_CellQualityCut {this, "CellQualityCut", 4000, "Qfactor value above which a channel is considered bad"}

private

Definition at line 102 of file LArNoisyROTool.h.

{this, "CellQualityCut", 4000, "Qfactor value above which a channel is considered bad"};

m_connChanPerHVline

Gaudi::Property<unsigned int> LArNoisyROTool::m_connChanPerHVline {this, "ConnectedChanPerHVline", 10, "min number of cells connected to HV line for it to be used for HV flag"}

private

Definition at line 124 of file LArNoisyROTool.h.

{this, "ConnectedChanPerHVline", 10, "min number of cells connected to HV line for it to be used for HV flag"};

m_doHVline

Gaudi::Property<bool> LArNoisyROTool::m_doHVline {this, "DoHVflag", true, "do HVline flagging"}

private

Definition at line 120 of file LArNoisyROTool.h.

{this, "DoHVflag", true, "do HVline flagging"};

m_elecID

const LArElectrodeID* LArNoisyROTool::m_elecID = nullptr

private

Definition at line 99 of file LArNoisyROTool.h.

m_hvMapTool

ToolHandle<ILArHVMapTool> LArNoisyROTool::m_hvMapTool {"LArHVMapTool"}

private

Definition at line 95 of file LArNoisyROTool.h.

{"LArHVMapTool"};

m_ignore_front_innerwheel_cells

Gaudi::Property<bool> LArNoisyROTool::m_ignore_front_innerwheel_cells {this, "IgnoreFrontInnerWheelCells", true, "ignore front inner wheel cells ?"}

private

Definition at line 106 of file LArNoisyROTool.h.

{this, "IgnoreFrontInnerWheelCells", true, "ignore front inner wheel cells ?"};

m_ignore_masked_cells

Gaudi::Property<bool> LArNoisyROTool::m_ignore_masked_cells {this, "IgnoreMaskedCells", false, "ignore masked cells"}

private

Definition at line 104 of file LArNoisyROTool.h.

{this, "IgnoreMaskedCells", false, "ignore masked cells"};

m_mapPSFEB

std::unordered_map<unsigned int, unsigned int> LArNoisyROTool::m_mapPSFEB

private

Definition at line 86 of file LArNoisyROTool.h.

m_MinBadFEB

Gaudi::Property<unsigned int> LArNoisyROTool::m_MinBadFEB {this, "BadFEBCut", 3, "min number of bad FEB to put LAr warning in event info"}

private

Definition at line 110 of file LArNoisyROTool.h.

{this, "BadFEBCut", 3, "min number of bad FEB to put LAr warning in event info"};

m_MinBadHV

Gaudi::Property<unsigned int> LArNoisyROTool::m_MinBadHV {this, "BadHVCut", 3, " min number of bad HV lines"}

private

Definition at line 123 of file LArNoisyROTool.h.

{this, "BadHVCut", 3, " min number of bad HV lines"};

m_MNBLooseCut

Gaudi::Property<unsigned int> LArNoisyROTool::m_MNBLooseCut {this, "MNBLooseCut", 5, "Loose cut on number of cells above CellQualityCut"}

private

Definition at line 126 of file LArNoisyROTool.h.

{this, "MNBLooseCut", 5, "Loose cut on number of cells above CellQualityCut"};

m_MNBTight_PsVetoCut

Gaudi::Property<std::vector<unsigned int> > LArNoisyROTool::m_MNBTight_PsVetoCut {this, "MNBTight_PsVetoCut", {13, 3}}

private

Definition at line 128 of file LArNoisyROTool.h.

{this, "MNBTight_PsVetoCut", {13, 3}};

m_MNBTightCut

Gaudi::Property<unsigned int> LArNoisyROTool::m_MNBTightCut {this, "MNBTightCut", 17, "Thight cut on number of cells above CellQualityCut"}

private

Definition at line 127 of file LArNoisyROTool.h.

{this, "MNBTightCut", 17, "Thight cut on number of cells above CellQualityCut"};

m_onlineID

const LArOnlineID* LArNoisyROTool::m_onlineID = nullptr

private

Definition at line 98 of file LArNoisyROTool.h.

m_partitionMask

std::array<uint8_t, 4> LArNoisyROTool::m_partitionMask

private

Initial value:

{
      {LArNoisyROSummary::EMECAMask, LArNoisyROSummary::EMBAMask, LArNoisyROSummary::EMBCMask, LArNoisyROSummary::EMECCMask}}

Definition at line 130 of file LArNoisyROTool.h.

                                      {
      {LArNoisyROSummary::EMECAMask, LArNoisyROSummary::EMBAMask, LArNoisyROSummary::EMBCMask, LArNoisyROSummary::EMECCMask}};

m_SaturatedCellEnergyTightCut

Gaudi::Property<float> LArNoisyROTool::m_SaturatedCellEnergyTightCut

private

Initial value:

{this, "SaturatedCellEnergyTightCut", 1000.,
                                                       "Count saturated Qfactor cells above this energy cut (absolute value)"}

Definition at line 115 of file LArNoisyROTool.h.

                                                    {this, "SaturatedCellEnergyTightCut", 1000.,
                                                       "Count saturated Qfactor cells above this energy cut (absolute value)"};

m_SaturatedCellQualityCut

Gaudi::Property<unsigned int> LArNoisyROTool::m_SaturatedCellQualityCut

private

Initial value:

{this, "SaturatedCellQualityCut", 65535,
                                                          " Qfactor value above which (>=) a channel is considered with a saturated Qfactor"}

Definition at line 112 of file LArNoisyROTool.h.

                                                       {this, "SaturatedCellQualityCut", 65535,
                                                          " Qfactor value above which (>=) a channel is considered with a saturated Qfactor"};

m_SaturatedCellTightCut

Gaudi::Property<unsigned int> LArNoisyROTool::m_SaturatedCellTightCut {this, "SaturatedCellTightCut", 20, "min number of saturated Qfactor cells to declare an event bad"}

private

Definition at line 118 of file LArNoisyROTool.h.

{this, "SaturatedCellTightCut", 20, "min number of saturated Qfactor cells to declare an event bad"};

---

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

• LArNoisyROTool.h
• LArNoisyROTool.cxx