TileDigitsMonitorAlgorithm Class Reference

Class for Tile digi noise based monitoring. More...

#include <TileDigitsMonitorAlgorithm.h>

Inheritance diagram for TileDigitsMonitorAlgorithm:

Collaboration diagram for TileDigitsMonitorAlgorithm:

Public Types
enum class	Environment_t {   user = 0 , online , tier0 , tier0Raw ,   tier0ESD , AOD , altprod }
	Specifies the processing environment. More...
enum class	DataType_t {   userDefined = 0 , monteCarlo , collisions , cosmics ,   heavyIonCollisions }
	Specifies what type of input data is being monitored. More...

Public Member Functions
virtual	~TileDigitsMonitorAlgorithm ()=default
virtual StatusCode	initialize () override
	initialize
virtual StatusCode	fillHistograms (const EventContext &ctx) const override
	adds event to the monitoring histograms
	TileCalibMonitorAlgorithm (const std::string &name, ISvcLocator *svcLocator)
	AthMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual StatusCode	execute (const EventContext &ctx) const override
	Applies filters and trigger requirements.
void	fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &&variables) const
	Fills a vector of variables to a group by reference.
void	fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &variables) const
	Fills a vector of variables to a group by reference.
template<typename... T>
void	fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
	Fills a variadic list of variables to a group by reference.
void	fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &&variables) const
	Fills a vector of variables to a group by name.
void	fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &variables) const
	Fills a vector of variables to a group by name.
template<typename... T>
void	fill (const std::string &groupName, T &&... variables) const
	Fills a variadic list of variables to a group by name.
Environment_t	environment () const
	Accessor functions for the environment.
Environment_t	envStringToEnum (const std::string &str) const
	Convert the environment string from the python configuration to an enum object.
DataType_t	dataType () const
	Accessor functions for the data type.
DataType_t	dataTypeStringToEnum (const std::string &str) const
	Convert the data type string from the python configuration to an enum object.
const ToolHandle< GenericMonitoringTool > &	getGroup (const std::string &name) const
	Get a specific monitoring tool from the tool handle array.
const ToolHandle< Trig::TrigDecisionTool > &	getTrigDecisionTool () const
	Get the trigger decision tool member.
bool	trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
	Check whether triggers are passed.
SG::ReadHandle< xAOD::EventInfo >	GetEventInfo (const EventContext &) const
	Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
virtual float	lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the average mu, i.e.
virtual float	lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate instantaneous number of interactions, i.e.
virtual float	lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float	lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the instantaneous luminosity per bunch crossing.
virtual double	lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the duration of the luminosity block (in seconds)
virtual float	lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the average luminosity livefraction.
virtual float	livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the live fraction per bunch crossing ID.
virtual double	lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Calculate the average integrated luminosity multiplied by the live fraction.
virtual StatusCode	parseList (const std::string &line, std::vector< std::string > &result) const
	Parse a string into a vector.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) 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	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

Public Attributes
	flags = initConfigFlags()
	Files
	AtlasVersion
	GlobalTag
	HISTFileName
	useTrigger
	enableLumiAccess
	MaxEvents
	cfg = MainServicesCfg(flags)
	withDetails
	True
	summariseProps
	sc = cfg.run()

Protected Types
enum	RunType {   UNKNOWN_RUN = 0 , PHYS_RUN = 1 , LAS_RUN = 2 , LED_RUN = 3 ,   PED_RUN = 4 , CIS_RUN = 8 , MONO_RUN = 9 , CIS_RAMP_RUN = 10 }
	Describes Tile Run Type. More...

Protected Member Functions
bool	isHeaderFormatError (uint32_t header) const
bool	isHeaderParityError (uint32_t header) const
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.

Protected Attributes
Gaudi::Property< std::string >	m_tileInfoName
Gaudi::Property< std::vector< int > >	m_fragIDsToIgnoreDMUerrors
Gaudi::Property< std::vector< int > >	m_fragIDsDemonstrators
Gaudi::Property< int >	m_runType
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
ServiceHandle< TileCablingSvc >	m_cablingSvc
	Name of Tile cabling service.
const TileCablingService *	m_cabling {nullptr}
const TileHWID *	m_tileHWID {nullptr}
const TileInfo *	m_tileInfo {nullptr}
ToolHandleArray< GenericMonitoringTool >	m_tools {this,"GMTools",{}}
	Array of Generic Monitoring Tools.
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDecTool
	Tool to tell whether a specific trigger is passed.
ToolHandleArray< IDQFilterTool >	m_DQFilterTools {this,"FilterTools",{}}
	Array of Data Quality filter tools.
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData >	m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData >	m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
AthMonitorAlgorithm::Environment_t	m_environment
	Instance of the Environment_t enum.
AthMonitorAlgorithm::DataType_t	m_dataType
	Instance of the DataType_t enum.
Gaudi::Property< std::string >	m_environmentStr {this,"Environment","user"}
	Environment string pulled from the job option and converted to enum.
Gaudi::Property< std::string >	m_dataTypeStr {this,"DataType","userDefined"}
	DataType string pulled from the job option and converted to enum.
Gaudi::Property< std::string >	m_triggerChainString {this,"TriggerChain",""}
	Trigger chain string pulled from the job option and parsed into a vector.
std::vector< std::string >	m_vTrigChainNames
	Vector of trigger chain names parsed from trigger chain string.
Gaudi::Property< std::string >	m_fileKey {this,"FileKey",""}
	Internal Athena name for file.
Gaudi::Property< bool >	m_useLumi {this,"EnableLumi",false}
	Allows use of various luminosity functions.
Gaudi::Property< float >	m_defaultLBDuration {this,"DefaultLBDuration",60.}
	Default duration of one lumi block.
Gaudi::Property< int >	m_detailLevel {this,"DetailLevel",0}
	Sets the level of detail used in the monitoring.
SG::ReadHandleKey< xAOD::EventInfo >	m_EventInfoKey {this,"EventInfoKey","EventInfo"}
	Key for retrieving EventInfo from StoreGate.

Private Types
enum	TileFragStatus {   ALL_OK = 0 , ALL_FF = 0x10 , ALL_00 = 0x20 , NO_FRAG = 0x40 ,   NO_ROB = 0x80 }
enum	TileDigiErrors {   OK , HEADER_FORM , HEADER_PAR , MEMO_PAR ,   SINGLE_STB , DOUBLE_STB , DUMMY_FRAG , NO_RECO_FRAG }
typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > >	MonVarVec_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	checkCRC (bool isCalibMode, uint32_t crc32, uint32_t crcMask, int nDMU, int ros, int drawer) const
StatusCode	checkROD_CRC (const TileDQstatus *dqStatus, const EventContext &ctx) const
bool	checkCorruptedData (const std::vector< std::reference_wrapper< const std::vector< uint32_t > > > &headerWordsAll, uint32_t fragStatus, int ros, int drawer, std::vector< std::vector< bool > > &corruptedData) const
void	checkBCID (const std::vector< std::reference_wrapper< const std::vector< uint32_t > > > &headerWordsAll, uint32_t rodBCID, int ros, int drawer) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_fillPedestalDifference
Gaudi::Property< bool >	m_fillErrorsHistograms
Gaudi::Property< bool >	m_fillPedestalHistograms
Gaudi::Property< bool >	m_fillHighFrequencyNoiseHistograms
Gaudi::Property< bool >	m_fillSamplesHistograms
Gaudi::Property< bool >	m_fillProfileHistograms
Gaudi::Property< bool >	m_fillEventModule32Histograms
Gaudi::Property< bool >	m_fillCorrelationsHistograms
SG::ReadHandleKey< TileDigitsContainer >	m_digitsContainerKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
ToolHandle< TileCondToolNoiseSample >	m_tileCondToolNoiseSample
std::vector< int >	m_meanSampleGroups
std::vector< int >	m_meanSampleProdGroups
std::vector< std::vector< int > >	m_crcGlobalGroups
std::vector< std::vector< int > >	m_crcErrGroups
std::vector< std::vector< std::vector< int > > >	m_bcidGroups
std::vector< std::vector< std::vector< int > > >	m_bcidErrGroups
std::vector< std::vector< std::vector< int > > >	m_errorsGroups
std::vector< std::vector< int > >	m_pedGroups
std::vector< std::vector< int > >	m_hfnGroups
std::vector< std::vector< int > >	m_samplesGroups
std::vector< std::vector< int > >	m_profGroups
std::vector< std::vector< int > >	m_evtMod32Groups
bool	m_is12bit {false}
float	m_ADCmaxMinusEpsilon
std::string	m_name
std::unordered_map< std::string, size_t >	m_toolLookupMap
const ToolHandle< GenericMonitoringTool >	m_dummy
Gaudi::Property< bool >	m_enforceExpressTriggers
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Static Private Attributes
static const int	MAX_DMU {16}

Detailed Description

Class for Tile digi noise based monitoring.

Definition at line 22 of file TileDigitsMonitorAlgorithm.h.

Member Typedef Documentation

MonVarVec_t

typedef std::vector<std::reference_wrapper<Monitored::IMonitoredVariable> > AthMonitorAlgorithm::MonVarVec_t

privateinherited

Definition at line 370 of file AthMonitorAlgorithm.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

DataType_t

enum class AthMonitorAlgorithm::DataType_t

stronginherited

Specifies what type of input data is being monitored.

An enumeration of the different types of data the monitoring application may be running over. This can be used to select which histograms to produce, e.g. to prevent the production of colliding-beam histograms when running on cosmic-ray data. Strings of the same names may be given as jobOptions.

Enumerator
userDefined
monteCarlo
collisions
cosmics
heavyIonCollisions

Definition at line 194 of file AthMonitorAlgorithm.h.

                          {
        userDefined = 0, 
        monteCarlo, 
        collisions, 
        cosmics, 
        heavyIonCollisions, 
    };

Environment_t

enum class AthMonitorAlgorithm::Environment_t

stronginherited

Specifies the processing environment.

The running environment may be used to select which histograms are produced, and where they are located in the output. For example, the output paths of the histograms are different for the "user", "online" and the various offline flags. Strings of the same names may be given as jobOptions.

Enumerator
user
online
tier0
tier0Raw
tier0ESD
AOD
altprod

Definition at line 175 of file AthMonitorAlgorithm.h.

                             {
        user = 0, 
        online, 
        tier0, 
        tier0Raw, 
        tier0ESD, 
        AOD, 
        altprod, 
    };

RunType

enum TileCalibMonitorAlgorithm::RunType

protectedinherited

Describes Tile Run Type.

Enumerator
UNKNOWN_RUN
PHYS_RUN
LAS_RUN
LED_RUN
PED_RUN
CIS_RUN
MONO_RUN
CIS_RAMP_RUN

Definition at line 64 of file TileCalibMonitorAlgorithm.h.

                 {
       UNKNOWN_RUN  = 0, // expect monogain
       PHYS_RUN = 1, // expect monogain
       LAS_RUN  = 2, // expect monogain
       LED_RUN  = 3, // expect monogain
       PED_RUN  = 4, // expect bigain
       CIS_RUN  = 8, // expect bigain
       MONO_RUN = 9, // expect monogain
       CIS_RAMP_RUN = 10 // expect monogain
    };

TileDigiErrors

enum TileDigitsMonitorAlgorithm::TileDigiErrors

private

Enumerator
OK
HEADER_FORM
HEADER_PAR
MEMO_PAR
SINGLE_STB
DOUBLE_STB
DUMMY_FRAG
NO_RECO_FRAG

Definition at line 35 of file TileDigitsMonitorAlgorithm.h.

                        {OK, HEADER_FORM, HEADER_PAR, MEMO_PAR, SINGLE_STB, DOUBLE_STB,
                         DUMMY_FRAG, NO_RECO_FRAG};

TileFragStatus

enum TileDigitsMonitorAlgorithm::TileFragStatus

private

Enumerator
ALL_OK
ALL_FF
ALL_00
NO_FRAG
NO_ROB

Definition at line 33 of file TileDigitsMonitorAlgorithm.h.

{ALL_OK = 0, ALL_FF = 0x10, ALL_00 = 0x20, NO_FRAG = 0x40, NO_ROB = 0x80};

Constructor & Destructor Documentation

~TileDigitsMonitorAlgorithm()

virtual TileDigitsMonitorAlgorithm::~TileDigitsMonitorAlgorithm ( )

virtualdefault

Member Function Documentation

AthMonitorAlgorithm()

AthMonitorAlgorithm::AthMonitorAlgorithm ( const std::string & name, ISvcLocator * pSvcLocator )

inherited

Constructor.

Definition at line 45 of file AthMonitorAlgorithm.cxx.

:AthReentrantAlgorithm(name,pSvcLocator)
 // Put this here rather than in the header to allow forward-declaring
 // TrigDecisionTool.
,m_trigDecTool{this, "TrigDecisionTool",""}
,m_environment(Environment_t::user)
,m_dataType(DataType_t::userDefined)
,m_vTrigChainNames({})
{}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

checkBCID()

void TileDigitsMonitorAlgorithm::checkBCID ( const std::vector< std::reference_wrapper< const std::vector< uint32_t > > > & headerWordsAll, uint32_t rodBCID, int ros, int drawer ) const

private

Definition at line 532 of file TileDigitsMonitorAlgorithm.cxx.

                                                                                        {
 
  int gain = 0;
  int partition = ros - 1;
  for (auto headerWords : headerWordsAll) {
    int dmu = 0;
    for (uint32_t header : headerWords.get() ) {
      uint32_t dmuBCID = (header & 0xFFF);
      auto monBCID  = Monitored::Scalar<int>("BCID_" + std::to_string(dmu), dmuBCID);
      fill(m_tools[m_bcidGroups[partition][drawer][gain]], monBCID);
 
      if ((dmuBCID == rodBCID) || (rodBCID > 0 && dmuBCID == rodBCID - 1)
          || ((rodBCID == 0) && ((dmuBCID == 3563) || (dmuBCID == 3564)))) {
 
        auto monBCIDErr = Monitored::Scalar<int>("BCID_err_" + std::to_string(dmu), 1);
        fill(m_tools[m_bcidErrGroups[partition][drawer][gain]], monBCIDErr);
      }
      ++dmu;
    }
    ++gain;
  }
}

checkCorruptedData()

bool TileDigitsMonitorAlgorithm::checkCorruptedData ( const std::vector< std::reference_wrapper< const std::vector< uint32_t > > > & headerWordsAll, uint32_t fragStatus, int ros, int drawer, std::vector< std::vector< bool > > & corruptedData ) const

private

Definition at line 429 of file TileDigitsMonitorAlgorithm.cxx.

                                                                                                                                               {
 
  using Tile = TileCalibUtils;
  int partition = ros - 1;
 
  std::vector<int> errors;
  auto errorsInDMUs = Monitored::Collection("Error", errors);
 
  std::vector<int> dmus;
  auto drawerDMUs = Monitored::Collection("DMU", dmus);
 
  TileDigiErrors error(OK);
  if (fragStatus != TileFragStatus::ALL_OK) {
    if (fragStatus & (TileFragStatus::ALL_FF | TileFragStatus::ALL_00)) {
      error = DUMMY_FRAG;
    } else if (fragStatus & (TileFragStatus::NO_FRAG | TileFragStatus::NO_ROB)) {
      error = NO_RECO_FRAG;
    }
    for (int dmu = 0; dmu < MAX_DMU; ++dmu) {
      dmus.push_back(dmu);
      errors.push_back(error);
    }
    if (m_fillErrorsHistograms) {
      for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
        fill(m_tools[m_errorsGroups[partition][drawer][gain]], drawerDMUs, errorsInDMUs);
      }
    }
    return true;
  }
 
  /*
   * DMU header format as defined in http://www.sysf.physto.se/~klere/tile-dmu/header.html
   * Bits: 1pllllesdrvvvv0mmgggbbbbbbbbbbbb
   *
   * The header starts with bit 31 set to indicate a header. The other bits as follows:
   * p  -   Parity (odd)
   * l  -   Derandomizer length (number of samples).
   * e  -   Parity error. A parity error was detected from the memory in the last readout.
   * s  -   SEstr Single Error Strobe recieved from the ttc.
   * d  -   DEstr Double Error Strobe recieved from the ttc.
   * r  -   Register parity. Parity from the registers in the chip.
   * v  -   Variable parity. Parity from the variables in the chip.
   * 0  -   Not used. (Set to 0)
   * m  -   Mode.   00 - Normal mode
   *                     01 - Calibration mode
   *                     10 - Test mode
   *                     11 - Not used
   * g  -   High/low gain. Indicates high(1) or low(0) amplification from the 3-in-1 cards.
   * b  -   Bunch Crossing.
   */
 
  int gain = 0;
  for (auto headerWords : headerWordsAll) {
    int dmu = 0;
    dmus.clear();
    errors.clear();
    for (uint32_t header : headerWords.get() ) {
      error = OK;
      if (isHeaderFormatError(header)) {
        corruptedData[gain][dmu] = true;
        dmus.push_back(dmu);
        errors.push_back(HEADER_FORM);
      } else if (isHeaderParityError(header)) {
        corruptedData[gain][dmu] = true;
        dmus.push_back(dmu);
        errors.push_back(HEADER_PAR);
      } else {
        if ((header >> 25) & 0x1) {
          dmus.push_back(dmu);
          error = MEMO_PAR;
          errors.push_back(error);
        }
        if ((header >> 24) & 0x1) {
          dmus.push_back(dmu);
          error = SINGLE_STB;
          errors.push_back(error);
        }
        if ((header >> 23) & 0x1) {
          dmus.push_back(dmu);
          error = DOUBLE_STB;
          errors.push_back(error);
        }
        if (error == OK) {
          dmus.push_back(dmu);
          errors.push_back(OK);
        } else {
          int fragId = m_tileHWID->frag(ros, drawer);
          if (!std::binary_search(m_fragIDsToIgnoreDMUerrors.begin(), m_fragIDsToIgnoreDMUerrors.end(), fragId)) {
            corruptedData[gain][dmu] = true;
          }
        }
      }
      ++dmu;
    }
    if (m_fillErrorsHistograms) {
      fill(m_tools[m_errorsGroups[partition][drawer][gain]], drawerDMUs, errorsInDMUs);
    }
    ++gain;
  }
  return false;
}

checkCRC()

void TileDigitsMonitorAlgorithm::checkCRC ( bool isCalibMode, uint32_t crc32, uint32_t crcMask, int nDMU, int ros, int drawer ) const

private

bigain: dummy information

Definition at line 294 of file TileDigitsMonitorAlgorithm.cxx.

                                                                               {
  /*
   * Author: Luca. F. November 06
   * This method provides CRC checks for Global and TileDMU chips.
   * Global CRC is taken from the trailer and it is correct if
   * the first 16 bits and the last 16 bits of the word match.
   * TileDMU CRC is taken from the DMU mask filled in the FPGA.
   * At the moment it makes sense only for monogain runs
   * (Physics, LED, MonoCIS). The least significant 16 bits are the result of
   * the CRC check in the FE (0xFFFF means all OK).  The most significant 16 bits
   * are the result of the CRC check in the ROD (0xFFFF means all OK).
   */
 
  int partition = ros - 1;
 
  // array to adjust order of DMU's of EB* FE CRC status in DMU chip mask word
  // this is needed because FE and ROD fill DMU mask word in different order
  int dmuFE_EB[16]         = { 0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 8, 9, 10, 11, 14, 15 };
  int dmuFE_EB_special[16] = { 11, 0, 1, 2, 3, 4, 5, 6, 12, 13, 7, 8, 9, 10, 14, 15 };
 
  // global CRC
  uint32_t crc0 = crc32 & 0xFFFF;
  uint32_t crc1 = crc32 >> 16;
 
  int crcGlobal = (crc32 == 0) ? 0 : (crc0 == crc1) ? 1 : 2;
  auto monGlobalCRC  = Monitored::Scalar<int>("CRC_global", crcGlobal);
  fill(m_tools[m_crcGlobalGroups[partition][drawer]], monGlobalCRC);
 
  // CRC per TileDMU. For mono gain we have it from ROD and FE.
  // In bi gain, it is just a placeholder with global CRC information.
  if (isCalibMode) { 
    for (int dmu = 0; dmu < nDMU; ++dmu) {
      auto monCRCErr  = Monitored::Scalar<int>("CRC_err_" + std::to_string(dmu), crcGlobal);
      fill(m_tools[m_crcErrGroups[partition][drawer]], monCRCErr);
    }
  } else {
    /*
     * monogain: meaningful information.
     * Fill 0 if crc32 if 0
     * Fill 1 if both FE and ROD crc is 1
     * Fill 2 if DMU FE crc is 0
     * Fill 3 if DMU ROD crc is 0
     * Fill 4 is FE and ROD crc is 0
     */
    int crcError = -1;
    if (crc32 == 0) {
      crcError = 0;
      for (int dmu = 0; dmu < nDMU; ++dmu) {
        auto monCRCErr  = Monitored::Scalar<int>("CRC_err_" + std::to_string(dmu), crcError);
        fill(m_tools[m_crcErrGroups[partition][drawer]], monCRCErr);
      }
    } else if (crcMask == 0xFFFFFFFF) {
      crcError = 1;
      for (int dmu = 0; dmu < nDMU; ++dmu) {
        auto monCRCErr  = Monitored::Scalar<int>("CRC_err_" + std::to_string(dmu), crcError);
        fill(m_tools[m_crcErrGroups[partition][drawer]], monCRCErr);
      }
    } else {
      uint32_t fe_crc = crcMask & 0xFFFF;
      uint32_t rod_crc = crcMask >> 16;
      for (int dmu = 0; dmu < nDMU; ++dmu) {
        crcError = 1; // TileDMU is fine
        if (ros < 3) { // LB* use simple FE CRC map
          if ((fe_crc >> dmu & 0x1) == 0x0) {
            ++crcError; // add FE error
          }
        } else {
          // EB* use different FECRC map
          if ((ros == 3 && drawer == 14) || (ros == 4 && drawer == 17)) {
            // Special EBA15, EBC18
            if ((fe_crc >> dmuFE_EB_special[dmu] & 0x1) == 0x0) {
              ++crcError; // add FE error
            }
          } else {
            if ((fe_crc >> dmuFE_EB[dmu] & 0x1) == 0x0) {
              ++crcError; // add FE error
            }
          }
        }
        if ((rod_crc >> dmu & 0x1) == 0x0) {
          crcError += 2; // add ROD error
        }
 
        auto monCRCErr  = Monitored::Scalar<int>("CRC_err_" + std::to_string(dmu), crcError);
        fill(m_tools[m_crcErrGroups[partition][drawer]], monCRCErr);
 
      }
    }
  }
}

checkROD_CRC()

StatusCode TileDigitsMonitorAlgorithm::checkROD_CRC ( const TileDQstatus * dqStatus, const EventContext & ctx ) const

private

Definition at line 387 of file TileDigitsMonitorAlgorithm.cxx.

                                                                                                               {
 
  /*
   * Author: Luca. F. Mar 08
   * This method provides CRC checks for Global and TileDMU chips.
   * They are taken from the the ROD RawChannel Container
   * TileDMU CRC is taken from the DMU mask filled in the FPGA.
   * It makes sense only for monogain runs
   * (Physics, LED, MonoCIS). The least significant 16 bits are the result of
   * the CRC check in the FE (0xFFFF means all OK).  The most significant 16 bits
   * are the result of the CRC check in the ROD (0xFFFF means all OK).
   * Global CRC is taken also from the DQ Fragment. '0' means OK,
   * '1' means mismatch.
   */
 
  SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(m_rawChannelContainerKey, ctx);
  ATH_CHECK( rawChannelContainer.isValid() );
 
  for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
    if (rawChannelCollection->empty()) continue;
 
    HWIdentifier hwid = rawChannelCollection->front()->adc_HWID(); // take the first channel in the drawer
    int ros = m_tileHWID->ros(hwid);  // take the ros and drawer from the first channel
    int drawer = m_tileHWID->drawer(hwid);
    uint32_t crc32 = rawChannelCollection->getFragGlobalCRC() & 1;
 
    if (crc32 == 0) {
      crc32 = 0xFFFFFFFF;
    } else { // means OK CRC match
      crc32 = 0xFFFF;
    } //means NOT OK, CRC mismatch
 
    uint32_t maskCRC = rawChannelCollection->getFragRODChipMask();
    maskCRC = maskCRC << 16; // ROD mask is stored in the 16 most significant bits ce
    maskCRC += rawChannelCollection->getFragFEChipMask();
    checkCRC(dqStatus, crc32, maskCRC, 16, ros, drawer); // reuse the same funcion used for digits
  }
 
  return StatusCode::SUCCESS;
}

dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const

inlineinherited

Accessor functions for the data type.

Returns

the current value of the class's DataType_t instance.

Definition at line 224 of file AthMonitorAlgorithm.h.

{ return m_dataType; }

dataTypeStringToEnum()

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::dataTypeStringToEnum ( const std::string & str ) const

inherited

Convert the data type string from the python configuration to an enum object.

Returns

a value in the DataType_t enumeration which matches the input string.

Definition at line 144 of file AthMonitorAlgorithm.cxx.

                                                                                                    {
    // convert the string to all lowercase
    std::string lowerCaseStr = str;
    std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
 
    // check if it matches one of the enum choices
    if( lowerCaseStr == "userdefined" ) {
        return DataType_t::userDefined;
    } else if( lowerCaseStr == "montecarlo" ) {
        return DataType_t::monteCarlo;
    } else if( lowerCaseStr == "collisions" ) {
        return DataType_t::collisions;
    } else if( lowerCaseStr == "cosmics" ) {
        return DataType_t::cosmics;
    } else if( lowerCaseStr == "heavyioncollisions" ) {
        return DataType_t::heavyIonCollisions;
    } else { // otherwise, warn the user and return "userDefined"
        ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
            <<str<<", returning userDefined.");
        return DataType_t::userDefined;
    }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

environment()

Environment_t AthMonitorAlgorithm::environment ( ) const

inlineinherited

Accessor functions for the environment.

Returns

the current value of the class's Environment_t instance.

Definition at line 208 of file AthMonitorAlgorithm.h.

{ return m_environment; }

envStringToEnum()

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::envStringToEnum ( const std::string & str ) const

inherited

Convert the environment string from the python configuration to an enum object.

Returns

a value in the Environment_t enumeration which matches the input string.

Definition at line 116 of file AthMonitorAlgorithm.cxx.

                                                                                                  {
    // convert the string to all lowercase
    std::string lowerCaseStr = str;
    std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
 
    // check if it matches one of the enum choices
    if( lowerCaseStr == "user" ) {
        return Environment_t::user;
    } else if( lowerCaseStr == "online" ) {
        return Environment_t::online;
    } else if( lowerCaseStr == "tier0" ) {
        return Environment_t::tier0;
    } else if( lowerCaseStr == "tier0raw" ) {
        return Environment_t::tier0Raw;
    } else if( lowerCaseStr == "tier0esd" ) {
        return Environment_t::tier0ESD;
    } else if( lowerCaseStr == "aod" ) {
        return Environment_t::AOD;
    } else if( lowerCaseStr == "altprod" ) {
        return Environment_t::altprod;
    } else { // otherwise, warn the user and return "user"
        ATH_MSG_WARNING("AthMonitorAlgorithm::envStringToEnum(): Unknown environment "
            <<str<<", returning user.");
        return Environment_t::user;
    }
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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; }

execute()

StatusCode AthMonitorAlgorithm::execute ( const EventContext & ctx ) const

overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters

ctx	event context for reentrant Athena call

Returns

StatusCode

Definition at line 77 of file AthMonitorAlgorithm.cxx.

                                                                       {
 
    // Checks that all of the  DQ filters are passed. If any one of the filters
    // fails, return SUCCESS code and do not fill the histograms with the event.
    for ( const auto& filterItr : m_DQFilterTools ) {
        if (!filterItr->accept()) {
            ATH_MSG_DEBUG("Event rejected due to filter tool.");
            return StatusCode::SUCCESS;
        }
    }
 
    // Trigger: If there is a decision tool and the chains fail, skip the event.
    if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
        ATH_MSG_DEBUG("Event rejected due to trigger filter.");
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("Event accepted!");
    return fillHistograms(ctx);
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

fillHistograms()

StatusCode TileDigitsMonitorAlgorithm::fillHistograms ( const EventContext & ctx ) const

overridevirtual

adds event to the monitoring histograms

User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.

Parameters

ctx	forwarded from execute

Returns

StatusCode

Implements TileCalibMonitorAlgorithm.

Definition at line 87 of file TileDigitsMonitorAlgorithm.cxx.

                                                                                     {
 
  using Tile = TileCalibUtils;
 
  // In case you want to measure the execution time
  auto timer = Monitored::Timer("TIME_execute");
 
  std::vector<float> meanSample[Tile::MAX_GAIN];
  std::vector<float> meanSampleChannel[Tile::MAX_GAIN];
 
  std::vector<float> meanSampleProd[Tile::MAX_GAIN];
  std::vector<float> meanSampleProdChannel1[Tile::MAX_GAIN];
  std::vector<float> meanSampleProdChannel2[Tile::MAX_GAIN];
 
  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  // array of CIS parameters
  const uint32_t* cispar = dqStatus->cispar();
 
  SG::ReadHandle<TileDigitsContainer> digitsContainer(m_digitsContainerKey, ctx);
  ATH_CHECK( digitsContainer.isValid() );
 
  for (const TileDigitsCollection* digitsCollection : *digitsContainer) {
    if (digitsCollection->empty() ) continue;
 
    HWIdentifier adc_id = digitsCollection->front()->adc_HWID();
    int ros = m_tileHWID->ros(adc_id);
    int drawer = m_tileHWID->drawer(adc_id);
    unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
    int partition = ros - 1;
 
    const std::vector<uint32_t>& headerWordsLow = digitsCollection->getFragChipHeaderWords();
    const std::vector<uint32_t>& headerWordsHigh = digitsCollection->getFragChipHeaderWordsHigh();
    std::vector<std::reference_wrapper<const std::vector<uint32_t>>> headerWordsAll{headerWordsLow};
    if (headerWordsHigh.empty()) {
      // For mono gain run fill the plots with the same info for high gain
      headerWordsAll.push_back(headerWordsLow);
    } else {
      headerWordsAll.push_back(headerWordsHigh);
    }
 
    std::vector<std::vector<bool>> corruptedData(Tile::MAX_GAIN, std::vector<bool>(MAX_DMU));
    uint32_t fragStatus = digitsCollection->getFragStatus();
    if (checkCorruptedData(headerWordsAll, fragStatus, ros, drawer, corruptedData)) {
      continue; // Dummy fragment or no fragment => nothing to check
    }
 
    if (m_fillErrorsHistograms) {
      uint32_t rodBCID = digitsCollection->getRODBCID();
      checkBCID(headerWordsAll, rodBCID, ros, drawer);
 
      bool isCalibMode = (dqStatus->calibMode() == 1);
      if (isCalibMode) {
        // global and DMU CRC check
        int nDMU = headerWordsLow.size();
        uint32_t crc32 = digitsCollection->getFragCRC();
        uint32_t crcMask = digitsCollection->getFragDMUMask();
        checkCRC(isCalibMode, crc32, crcMask, nDMU, ros, drawer);
      }
    }
 
 
    // Below, the charge conversion for 12 bit is just an approximation;
    //   4095. can be changed later to gain precision if needed.
    double charge = 0;
    if (m_is12bit) { // if 12 bit ADCs
      charge = cispar[6] * cispar[7] * (2. * 4.096 / 4095.);
    } else {
      charge = cispar[6] * cispar[7] * (2. * 4.096 / 1023.);
    }
 
    const TileDigits* moduleDigits[Tile::MAX_CHAN][Tile::MAX_GAIN] = {{nullptr}};
 
    for (const TileDigits* tile_digits : *digitsCollection) {
 
      adc_id = tile_digits->adc_HWID();
      int channel = m_tileHWID->channel(adc_id);
      int adc = m_tileHWID->adc(adc_id);
 
      if (corruptedData[adc][channel / 3]) {
        continue;
      }
 
      moduleDigits[channel][adc] = tile_digits;
 
      std::string channelGainSuffix = "_" + std::to_string(channel) + "_" + std::to_string(adc);
 
      const std::vector<float>& digits = tile_digits->samples();
      unsigned int nSamples = digits.size();
 
      if (nSamples > 1) {
 
        if (m_fillPedestalHistograms) {
          double pedestal = digits[0];
 
          if(m_fillPedestalDifference) {
            pedestal -= m_tileCondToolNoiseSample->getPed(drawerIdx, channel, adc, TileRawChannelUnit::ADCcounts, ctx);
          }
 
          auto monSample0  = Monitored::Scalar<float>("sample0" + channelGainSuffix, pedestal);
          fill(m_tools[m_pedGroups[partition][drawer]], monSample0);
        }
 
 
        if (m_fillHighFrequencyNoiseHistograms) {
          double sampleMean = 0.0;
          double sampleRMS = 0.0;
 
          for (double sample : digits) {
            sampleMean += sample;
            sampleRMS += sample * sample;
            if (adc == 1 && sample > m_ADCmaxMinusEpsilon) {// overflow in high gain, find charge is it
              auto monCharge  = Monitored::Scalar<float>("charge", charge);
              fill("TileDigitsOverflow", monCharge);
            }
          }
 
          sampleMean /= nSamples;
          sampleRMS = sampleRMS / nSamples - sampleMean * sampleMean;
          sampleRMS = (sampleRMS > 0.0) ? sqrt(sampleRMS * nSamples / (nSamples - 1)) : 0.0;
 
          if (m_fillCorrelationsHistograms) {
            meanSample[adc].push_back(sampleMean);
            meanSampleChannel[adc].push_back(channel);
          }
 
          auto monMeanRMS  = Monitored::Scalar<float>("meanRMS" + channelGainSuffix, sampleRMS);
          fill(m_tools[m_hfnGroups[partition][drawer]], monMeanRMS);
        }
 
        if ((m_runType != CIS_RUN)
            || (cispar[6] > 0. && (adc < 1 || charge < 12.))) {
          // LF If CIS run, Protection to avoid zero amplitudes due to 0 injected charge
 
          if (m_fillSamplesHistograms) {
            auto monSamples = Monitored::Collection("samples" + channelGainSuffix, digits);
            fill(m_tools[m_samplesGroups[partition][drawer]], monSamples);
          }
 
          if (m_fillProfileHistograms) {
            auto monSamples = Monitored::Collection("samples" + channelGainSuffix, digits);
            std::vector<int> sampleNumbers(nSamples);
            std::iota(sampleNumbers.begin(), sampleNumbers.end(), 0);
            auto monSampleNumbers = Monitored::Collection("sampleNumbers" + channelGainSuffix, sampleNumbers);
            fill(m_tools[m_profGroups[partition][drawer]], monSampleNumbers, monSamples);
          }
        }
 
        if (m_fillEventModule32Histograms) {
          int evtMod32 = (ctx.evt() + 1) % 32;
          auto monEvtMod32 = Monitored::Scalar<int>("evtn_mod32" + channelGainSuffix, evtMod32);
          fill(m_tools[m_evtMod32Groups[partition][drawer]], monEvtMod32);
        }
 
      }
    } // digits
 
    if (m_fillCorrelationsHistograms) {
      for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
        if (!meanSampleChannel[gain].empty()) {
          auto monChannel = Monitored::Collection("channel_" + Tile::getDrawerString(ros, drawer), meanSampleChannel[gain]);
          auto monMeanSample = Monitored::Collection("meanSample_" + Tile::getDrawerString(ros, drawer), meanSample[gain]);
          fill(m_tools[m_meanSampleGroups[gain]], monChannel, monMeanSample);
 
          for (int channel1 : meanSampleChannel[gain]) {
            const std::vector<float>& digits1 = moduleDigits[channel1][gain]->samples();
            for (int channel2 : meanSampleChannel[gain]) {
              const std::vector<float>& digits2 = moduleDigits[channel2][gain]->samples();
              double sampleProdMean = 0.;
              unsigned int nSamples = digits1.size();
              for (unsigned int i = 0; i < nSamples; ++i) {
                sampleProdMean += digits1[i] * digits2[i];
              }
              sampleProdMean /= nSamples;
              meanSampleProd[gain].push_back(sampleProdMean);
              meanSampleProdChannel1[gain].push_back(channel1);
              meanSampleProdChannel2[gain].push_back(channel2);
            }
          }
          auto monChannel1 = Monitored::Collection("channel1_" + Tile::getDrawerString(ros, drawer), meanSampleProdChannel1[gain]);
          auto monChannel2 = Monitored::Collection("channel2_" + Tile::getDrawerString(ros, drawer), meanSampleProdChannel2[gain]);
          auto monMeanSampleProd = Monitored::Collection("meanSampleProd_" + Tile::getDrawerString(ros, drawer), meanSampleProd[gain]);
          fill(m_tools[m_meanSampleProdGroups[gain]], monChannel1, monChannel2, monMeanSampleProd);
 
          meanSample[gain].clear();
          meanSampleChannel[gain].clear();
 
          meanSampleProd[gain].clear();
          meanSampleProdChannel1[gain].clear();
          meanSampleProdChannel2[gain].clear();
 
        }
      }
    }
  }
 
  if (dqStatus->calibMode() == 0 && !m_rawChannelContainerKey.empty()) {
    if (checkROD_CRC(dqStatus, ctx).isFailure()) {
      ATH_MSG_WARNING("Not possible to check CRC from ROD");
    }
  }
 
  fill("TileDigitsMonExecuteTime", timer);
 
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

GetEventInfo()

SG::ReadHandle< xAOD::EventInfo > AthMonitorAlgorithm::GetEventInfo ( const EventContext & ctx ) const

inherited

Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)

Parameters

ctx	EventContext for the event

Returns

a SG::ReadHandle<xAOD::EventInfo>

Definition at line 111 of file AthMonitorAlgorithm.cxx.

                                                                                             {
    return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
}

getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( const std::string & name ) const

inherited

Get a specific monitoring tool from the tool handle array.

Finds a specific GenericMonitoringTool instance from the list of monitoring tools (a ToolHandleArray). Throws a FATAL warning if the object found is empty.

Parameters

name	string name of the desired tool

Returns

reference to the desired monitoring tool

Definition at line 168 of file AthMonitorAlgorithm.cxx.

                                                                                                    {
    // get the pointer to the tool, and check that it exists
    auto idx = m_toolLookupMap.find(name);
    if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
        return m_tools[idx->second];
    }
    else {
      // treat empty tool handle case as in Monitored::Group
      if (m_toolLookupMap.empty()) {
    return m_dummy;
      }
 
      if (!isInitialized()) {
        ATH_MSG_FATAL(
            "It seems that the AthMonitorAlgorithm::initialize was not called "
            "in derived class initialize method");
      } else {
        std::string available = std::accumulate(
            m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
            [](const std::string& s, auto h) { return s + "," + h.first; });
        ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
                      << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
                      << "your python configuration and c++ filling code. Note: your available groups are {"
                      << available << "}.");
        }
    }
    return m_dummy;
}

getTrigDecisionTool()

const ToolHandle< Trig::TrigDecisionTool > & AthMonitorAlgorithm::getTrigDecisionTool ( ) const

inherited

Get the trigger decision tool member.

The trigger decision tool is used to check whether a specific trigger is passed by an event.

Returns

m_trigDecTool

Definition at line 198 of file AthMonitorAlgorithm.cxx.

                                                                                       {
    return m_trigDecTool;
}

initialize()

StatusCode TileDigitsMonitorAlgorithm::initialize ( )

overridevirtual

initialize

Returns

StatusCode

Reimplemented from TileCalibMonitorAlgorithm.

Definition at line 12 of file TileDigitsMonitorAlgorithm.cxx.

                                                  {
 
  ATH_MSG_DEBUG("in initialize()");
 
  // initialize superclass
  ATH_CHECK( TileCalibMonitorAlgorithm::initialize() );
 
  ATH_CHECK( m_digitsContainerKey.initialize() );
  ATH_CHECK( m_rawChannelContainerKey.initialize(SG::AllowEmpty) );
  ATH_CHECK( m_tileCondToolNoiseSample.retrieve(EnableTool(m_fillPedestalDifference)) );
 
  m_ADCmaxMinusEpsilon = m_tileInfo->ADCmax() - 0.01;
  if (m_tileInfo->ADCmax() == 4095) {
    m_is12bit = true;
  }
 
  using Tile = TileCalibUtils;
  using namespace Monitored;
 
 
  if (m_fillErrorsHistograms) {
    m_errorsGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileDigitsErrors",
                                                                 Tile::MAX_ROS - 1, Tile::MAX_DRAWER,
                                                                 Tile::MAX_GAIN);
 
    m_bcidGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileDigitsBCID",
                                                               Tile::MAX_ROS - 1, Tile::MAX_DRAWER,
                                                               Tile::MAX_GAIN);
 
    m_bcidErrGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileDigitsBCIDErrors",
                                                                  Tile::MAX_ROS - 1, Tile::MAX_DRAWER,
                                                                  Tile::MAX_GAIN);
 
    m_crcErrGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsCRCErrors",
                                                    Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
 
    m_crcGlobalGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsGlobalCRC",
                                                       Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
 
  }
 
  if (m_fillCorrelationsHistograms) {
    m_meanSampleGroups = buildToolMap<int>(m_tools, "TileDigitsMeanSample", Tile::MAX_GAIN);
    m_meanSampleProdGroups = buildToolMap<int>(m_tools, "TileDigitsMeanSampleProd", Tile::MAX_GAIN);
  }
 
  if (m_fillPedestalHistograms) {
    m_pedGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsSample0",
                                                 Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
  }
 
  if (m_fillHighFrequencyNoiseHistograms) {
    m_hfnGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsMeanRMS",
                                                 Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
  }
 
  if (m_fillSamplesHistograms) {
    m_samplesGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsSamples",
                                                     Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
  }
 
  if (m_fillProfileHistograms) {
    m_profGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsProfile",
                                                  Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
  }
 
  if (m_fillEventModule32Histograms) {
    m_evtMod32Groups = buildToolMap<std::vector<int>>(m_tools, "TileDigitsEvtMod32",
                                                      Tile::MAX_ROS - 1, Tile::MAX_DRAWER);
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

isHeaderFormatError()

bool TileCalibMonitorAlgorithm::isHeaderFormatError ( uint32_t header ) const

inlineprotectedinherited

Definition at line 42 of file TileCalibMonitorAlgorithm.h.

                                                    {
      return (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0)) ? false : true;
    };

isHeaderParityError()

bool TileCalibMonitorAlgorithm::isHeaderParityError ( uint32_t header ) const

inlineprotectedinherited

Definition at line 51 of file TileCalibMonitorAlgorithm.h.

                                                    {
      uint32_t parity(0);
      for (int i = 0; i < 32; ++i) {
        parity += ((header >> i) & 0x1);
      }
      return ((parity % 2) == 1) ? false : true;
    };

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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.

parseList()

StatusCode AthMonitorAlgorithm::parseList ( const std::string & line, std::vector< std::string > & result ) const

virtualinherited

Parse a string into a vector.

The input string is a single long string of all of the trigger names. It parses this string and turns it into a vector, where each element is one trigger or trigger category.

Parameters

line	The input string.
result	The parsed output vector of strings.

Returns

StatusCode

Definition at line 345 of file AthMonitorAlgorithm.cxx.

                                                                                                   {
    std::string item;
    std::stringstream ss(line);
 
    ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
 
    while ( std::getline(ss, item, ',') ) {
        std::stringstream iss(item); // remove whitespace
        iss >> item;
        result.push_back(item);
    }
 
    return StatusCode::SUCCESS;
}

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

TileCalibMonitorAlgorithm()

TileCalibMonitorAlgorithm::TileCalibMonitorAlgorithm ( const std::string & name, ISvcLocator * svcLocator )

inline

Definition at line 25 of file TileCalibMonitorAlgorithm.h.

      :AthMonitorAlgorithm(name, svcLocator) {}

trigChainsArePassed()

bool AthMonitorAlgorithm::trigChainsArePassed ( const std::vector< std::string > & vTrigNames ) const

inherited

Check whether triggers are passed.

For the event, use the trigger decision tool to check that at least one of the triggers listed in the supplied vector is passed.

Parameters

vTrigNames

List of trigger names.

Returns

If empty input, default to true. If at least one trigger is specified, returns whether at least one trigger was passed.

Definition at line 203 of file AthMonitorAlgorithm.cxx.

                                                                                            {
 
  
  // If no triggers were given, return true.
  if (vTrigNames.empty()) return true;
  
  
  // Trigger: Check if this Algorithm is being run as an Express Stream job.
  // Events are entering the express stream are chosen randomly, and by chain,
  // Hence an additional check should be aplied to see if the chain(s)
  // monitored here are responsible for the event being selected for
  // the express stream.
 
  const auto group =  m_trigDecTool->getChainGroup(vTrigNames);
  if (m_enforceExpressTriggers){  
    const auto passedBits = m_trigDecTool->isPassedBits(group);
    bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
    if(!expressPass) {
      return false;
    }
  }
  
  // monitor the event if any of the chains in the chain group passes the event.
  return group->isPassed();
  
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

AtlasVersion

TileDigitsMonitorAlgorithm.AtlasVersion

Definition at line 261 of file TileDigitsMonitorAlgorithm.py.

cfg

TileDigitsMonitorAlgorithm.cfg = MainServicesCfg(flags)

Definition at line 272 of file TileDigitsMonitorAlgorithm.py.

enableLumiAccess

TileDigitsMonitorAlgorithm.enableLumiAccess

Definition at line 265 of file TileDigitsMonitorAlgorithm.py.

Files

TileDigitsMonitorAlgorithm.Files

Definition at line 260 of file TileDigitsMonitorAlgorithm.py.

flags

TileDigitsMonitorAlgorithm.flags = initConfigFlags()

Definition at line 259 of file TileDigitsMonitorAlgorithm.py.

GlobalTag

TileDigitsMonitorAlgorithm.GlobalTag

Definition at line 262 of file TileDigitsMonitorAlgorithm.py.

HISTFileName

TileDigitsMonitorAlgorithm.HISTFileName

Definition at line 263 of file TileDigitsMonitorAlgorithm.py.

m_ADCmaxMinusEpsilon

float TileDigitsMonitorAlgorithm::m_ADCmaxMinusEpsilon

private

Definition at line 94 of file TileDigitsMonitorAlgorithm.h.

m_bcidErrGroups

std::vector<std::vector<std::vector<int> > > TileDigitsMonitorAlgorithm::m_bcidErrGroups

private

Definition at line 83 of file TileDigitsMonitorAlgorithm.h.

m_bcidGroups

std::vector<std::vector<std::vector<int> > > TileDigitsMonitorAlgorithm::m_bcidGroups

private

Definition at line 82 of file TileDigitsMonitorAlgorithm.h.

m_cabling

const TileCablingService* TileCalibMonitorAlgorithm::m_cabling {nullptr}

protectedinherited

Definition at line 96 of file TileCalibMonitorAlgorithm.h.

{nullptr};

m_cablingSvc

ServiceHandle<TileCablingSvc> TileCalibMonitorAlgorithm::m_cablingSvc

protectedinherited

Initial value:

{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Name of Tile cabling service.

Definition at line 93 of file TileCalibMonitorAlgorithm.h.

                                              { this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};

m_crcErrGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_crcErrGroups

private

Definition at line 81 of file TileDigitsMonitorAlgorithm.h.

m_crcGlobalGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_crcGlobalGroups

private

Definition at line 80 of file TileDigitsMonitorAlgorithm.h.

m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType

protectedinherited

Instance of the DataType_t enum.

Definition at line 356 of file AthMonitorAlgorithm.h.

m_dataTypeStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_dataTypeStr {this,"DataType","userDefined"}

protectedinherited

DataType string pulled from the job option and converted to enum.

Definition at line 358 of file AthMonitorAlgorithm.h.

{this,"DataType","userDefined"}; 

m_defaultLBDuration

Gaudi::Property<float> AthMonitorAlgorithm::m_defaultLBDuration {this,"DefaultLBDuration",60.}

protectedinherited

Default duration of one lumi block.

Definition at line 365 of file AthMonitorAlgorithm.h.

{this,"DefaultLBDuration",60.}; 

m_detailLevel

Gaudi::Property<int> AthMonitorAlgorithm::m_detailLevel {this,"DetailLevel",0}

protectedinherited

Sets the level of detail used in the monitoring.

Definition at line 366 of file AthMonitorAlgorithm.h.

{this,"DetailLevel",0}; 

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileDigitsMonitorAlgorithm::m_digitsContainerKey

private

Initial value:

{this,
        "TileDigitsContainer", "TileDigitsCnt", "Input Tile digits container key"}

Definition at line 69 of file TileDigitsMonitorAlgorithm.h.

                                                             {this,
        "TileDigitsContainer", "TileDigitsCnt", "Input Tile digits container key"};

m_DQFilterTools

ToolHandleArray<IDQFilterTool> AthMonitorAlgorithm::m_DQFilterTools {this,"FilterTools",{}}

protectedinherited

Array of Data Quality filter tools.

Definition at line 346 of file AthMonitorAlgorithm.h.

{this,"FilterTools",{}}; 

m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileCalibMonitorAlgorithm::m_dqStatusKey

protectedinherited

Initial value:

{this,
        "TileDQstatus", "TileDQstatus", "Tile DQ status name"}

Definition at line 87 of file TileCalibMonitorAlgorithm.h.

                                               {this,
        "TileDQstatus", "TileDQstatus", "Tile DQ status name"};

m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy

privateinherited

Definition at line 374 of file AthMonitorAlgorithm.h.

m_enforceExpressTriggers

Gaudi::Property<bool> AthMonitorAlgorithm::m_enforceExpressTriggers

privateinherited

Initial value:

{this,
                          "EnforceExpressTriggers", false,
                          "Requires that matched triggers made the event enter the express stream"}

Definition at line 377 of file AthMonitorAlgorithm.h.

                                               {this,
                          "EnforceExpressTriggers", false,
                          "Requires that matched triggers made the event enter the express stream"};

m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment

protectedinherited

Instance of the Environment_t enum.

Definition at line 355 of file AthMonitorAlgorithm.h.

m_environmentStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_environmentStr {this,"Environment","user"}

protectedinherited

Environment string pulled from the job option and converted to enum.

Definition at line 357 of file AthMonitorAlgorithm.h.

{this,"Environment","user"}; 

m_errorsGroups

std::vector<std::vector<std::vector<int> > > TileDigitsMonitorAlgorithm::m_errorsGroups

private

Definition at line 84 of file TileDigitsMonitorAlgorithm.h.

m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AthMonitorAlgorithm::m_EventInfoKey {this,"EventInfoKey","EventInfo"}

protectedinherited

Key for retrieving EventInfo from StoreGate.

Definition at line 367 of file AthMonitorAlgorithm.h.

{this,"EventInfoKey","EventInfo"}; 

m_evtMod32Groups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_evtMod32Groups

private

Definition at line 90 of file TileDigitsMonitorAlgorithm.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_fileKey

Gaudi::Property<std::string> AthMonitorAlgorithm::m_fileKey {this,"FileKey",""}

protectedinherited

Internal Athena name for file.

Definition at line 363 of file AthMonitorAlgorithm.h.

{this,"FileKey",""}; 

m_fillCorrelationsHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillCorrelationsHistograms

private

Initial value:

{this,
        "fillCorrelationsHistograms", true, "Fill histograms which are used to produce correlation and corvariance plots"}

Definition at line 66 of file TileDigitsMonitorAlgorithm.h.

                                                    {this,
        "fillCorrelationsHistograms", true, "Fill histograms which are used to produce correlation and corvariance plots"};

m_fillErrorsHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillErrorsHistograms

private

Initial value:

{this,
        "fillErrorsHistograms", true, "Fill histograms per channel/gain with DMU, CRC, BCID errors"}

Definition at line 48 of file TileDigitsMonitorAlgorithm.h.

                                              {this,
        "fillErrorsHistograms", true, "Fill histograms per channel/gain with DMU, CRC, BCID errors"};

m_fillEventModule32Histograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillEventModule32Histograms

private

Initial value:

{this,
        "fillEventModule32Histograms", true, "Fill histograms per channel/gain with event number % 32"}

Definition at line 63 of file TileDigitsMonitorAlgorithm.h.

                                                     {this,
        "fillEventModule32Histograms", true, "Fill histograms per channel/gain with event number % 32"};

m_fillHighFrequencyNoiseHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillHighFrequencyNoiseHistograms

private

Initial value:

{this,
        "fillHighFrequencyNoiseHistograms", true, "Fill histograms per channel/gain with HFN"}

Definition at line 54 of file TileDigitsMonitorAlgorithm.h.

                                                          {this,
        "fillHighFrequencyNoiseHistograms", true, "Fill histograms per channel/gain with HFN"};

m_fillPedestalDifference

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillPedestalDifference

private

Initial value:

{this,
        "fillPedestalDifference", true, "Fill pedestal difference between monitored pedestal and one from DB"}

Definition at line 45 of file TileDigitsMonitorAlgorithm.h.

                                                {this,
        "fillPedestalDifference", true, "Fill pedestal difference between monitored pedestal and one from DB"};

m_fillPedestalHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillPedestalHistograms

private

Initial value:

{this,
        "fillPedestalHistograms", true, "Fill histograms per channel/gain with pedestals"}

Definition at line 51 of file TileDigitsMonitorAlgorithm.h.

                                                {this,
        "fillPedestalHistograms", true, "Fill histograms per channel/gain with pedestals"};

m_fillProfileHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillProfileHistograms

private

Initial value:

{this,
        "fillProfileHistograms", true, "Fill histograms per channel/gain with profile"}

Definition at line 60 of file TileDigitsMonitorAlgorithm.h.

                                               {this,
        "fillProfileHistograms", true, "Fill histograms per channel/gain with profile"};

m_fillSamplesHistograms

Gaudi::Property<bool> TileDigitsMonitorAlgorithm::m_fillSamplesHistograms

private

Initial value:

{this,
        "fillSamplesHistograms", true, "Fill histograms per channel/gain with samples"}

Definition at line 57 of file TileDigitsMonitorAlgorithm.h.

                                               {this,
        "fillSamplesHistograms", true, "Fill histograms per channel/gain with samples"};

m_fragIDsDemonstrators

Gaudi::Property<std::vector<int> > TileCalibMonitorAlgorithm::m_fragIDsDemonstrators

protectedinherited

Initial value:

{this,
        "FragIDsDemonstrators", {}, "List of Tile frag IDs of Demonstrators"}

Definition at line 81 of file TileCalibMonitorAlgorithm.h.

                                                        {this,
        "FragIDsDemonstrators", {}, "List of Tile frag IDs of Demonstrators"};

m_fragIDsToIgnoreDMUerrors

Gaudi::Property<std::vector<int> > TileCalibMonitorAlgorithm::m_fragIDsToIgnoreDMUerrors

protectedinherited

Initial value:

{this,
        "FragIDsToIgnoreDMUErrors", {}, "List of Tile frag IDs for which ignore DMU errors"}

Definition at line 78 of file TileCalibMonitorAlgorithm.h.

                                                            {this,
        "FragIDsToIgnoreDMUErrors", {}, "List of Tile frag IDs for which ignore DMU errors"};

m_hfnGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_hfnGroups

private

Definition at line 87 of file TileDigitsMonitorAlgorithm.h.

m_is12bit

bool TileDigitsMonitorAlgorithm::m_is12bit {false}

private

Definition at line 93 of file TileDigitsMonitorAlgorithm.h.

{false};

m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> AthMonitorAlgorithm::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}

protectedinherited

Definition at line 350 of file AthMonitorAlgorithm.h.

{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> AthMonitorAlgorithm::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}

protectedinherited

Definition at line 348 of file AthMonitorAlgorithm.h.

{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

m_meanSampleGroups

std::vector<int> TileDigitsMonitorAlgorithm::m_meanSampleGroups

private

Definition at line 78 of file TileDigitsMonitorAlgorithm.h.

m_meanSampleProdGroups

std::vector<int> TileDigitsMonitorAlgorithm::m_meanSampleProdGroups

private

Definition at line 79 of file TileDigitsMonitorAlgorithm.h.

m_name

std::string AthMonitorAlgorithm::m_name

privateinherited

Definition at line 371 of file AthMonitorAlgorithm.h.

m_pedGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_pedGroups

private

Definition at line 86 of file TileDigitsMonitorAlgorithm.h.

m_profGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_profGroups

private

Definition at line 89 of file TileDigitsMonitorAlgorithm.h.

m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileDigitsMonitorAlgorithm::m_rawChannelContainerKey

private

Initial value:

{this,
        "TileRawChannelContainer", "", "Input Tile raw channel container key"}

Definition at line 72 of file TileDigitsMonitorAlgorithm.h.

                                                                     {this,
        "TileRawChannelContainer", "", "Input Tile raw channel container key"};

m_runType

Gaudi::Property<int> TileCalibMonitorAlgorithm::m_runType

protectedinherited

Initial value:

{this,
        "RunType", 0, "Run type: 1 - phys, 2 - las, 4 - ped, 8 - cis, 9- mono"}

Definition at line 84 of file TileCalibMonitorAlgorithm.h.

                                {this,
        "RunType", 0, "Run type: 1 - phys, 2 - las, 4 - ped, 8 - cis, 9- mono"};

m_samplesGroups

std::vector<std::vector<int> > TileDigitsMonitorAlgorithm::m_samplesGroups

private

Definition at line 88 of file TileDigitsMonitorAlgorithm.h.

m_tileCondToolNoiseSample

ToolHandle<TileCondToolNoiseSample> TileDigitsMonitorAlgorithm::m_tileCondToolNoiseSample

private

Initial value:

{this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"}

Definition at line 75 of file TileDigitsMonitorAlgorithm.h.

                                                                 {this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"};

m_tileHWID

const TileHWID* TileCalibMonitorAlgorithm::m_tileHWID {nullptr}

protectedinherited

Definition at line 97 of file TileCalibMonitorAlgorithm.h.

{nullptr};

m_tileInfo

const TileInfo* TileCalibMonitorAlgorithm::m_tileInfo {nullptr}

protectedinherited

Definition at line 98 of file TileCalibMonitorAlgorithm.h.

{nullptr};

m_tileInfoName

Gaudi::Property<std::string> TileCalibMonitorAlgorithm::m_tileInfoName

protectedinherited

Initial value:

{this,
        "TileInfo", "TileInfo", "Name of TileInfo object in Detector Store"}

Definition at line 75 of file TileCalibMonitorAlgorithm.h.

                                           {this,
        "TileInfo", "TileInfo", "Name of TileInfo object in Detector Store"};

m_toolLookupMap

std::unordered_map<std::string, size_t> AthMonitorAlgorithm::m_toolLookupMap

privateinherited

Definition at line 372 of file AthMonitorAlgorithm.h.

m_tools

ToolHandleArray<GenericMonitoringTool> AthMonitorAlgorithm::m_tools {this,"GMTools",{}}

protectedinherited

Array of Generic Monitoring Tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

{this,"GMTools",{}}; 

m_trigDecTool

PublicToolHandle<Trig::TrigDecisionTool> AthMonitorAlgorithm::m_trigDecTool

protectedinherited

Tool to tell whether a specific trigger is passed.

Definition at line 345 of file AthMonitorAlgorithm.h.

m_triggerChainString

Gaudi::Property<std::string> AthMonitorAlgorithm::m_triggerChainString {this,"TriggerChain",""}

protectedinherited

Trigger chain string pulled from the job option and parsed into a vector.

Definition at line 360 of file AthMonitorAlgorithm.h.

{this,"TriggerChain",""}; 

m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> AthMonitorAlgorithm::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}

protectedinherited

Definition at line 352 of file AthMonitorAlgorithm.h.

{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"};

m_useLumi

Gaudi::Property<bool> AthMonitorAlgorithm::m_useLumi {this,"EnableLumi",false}

protectedinherited

Allows use of various luminosity functions.

Definition at line 364 of file AthMonitorAlgorithm.h.

{this,"EnableLumi",false}; 

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vTrigChainNames

std::vector<std::string> AthMonitorAlgorithm::m_vTrigChainNames

protectedinherited

Vector of trigger chain names parsed from trigger chain string.

Definition at line 361 of file AthMonitorAlgorithm.h.

MAX_DMU

const int TileDigitsMonitorAlgorithm::MAX_DMU {16}

staticprivate

Definition at line 92 of file TileDigitsMonitorAlgorithm.h.

{16};

MaxEvents

TileDigitsMonitorAlgorithm.MaxEvents

Definition at line 266 of file TileDigitsMonitorAlgorithm.py.

sc

TileDigitsMonitorAlgorithm.sc = cfg.run()

Definition at line 285 of file TileDigitsMonitorAlgorithm.py.

summariseProps

TileDigitsMonitorAlgorithm.summariseProps

Definition at line 280 of file TileDigitsMonitorAlgorithm.py.

True

TileDigitsMonitorAlgorithm.True

Definition at line 280 of file TileDigitsMonitorAlgorithm.py.

useTrigger

TileDigitsMonitorAlgorithm.useTrigger

Definition at line 264 of file TileDigitsMonitorAlgorithm.py.

withDetails

TileDigitsMonitorAlgorithm.withDetails

Definition at line 280 of file TileDigitsMonitorAlgorithm.py.

---

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

• TileDigitsMonitorAlgorithm.h
• TileDigitsMonitorAlgorithm.py
• TileDigitsMonitorAlgorithm.cxx