ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TileCellSelector Class Reference

#include <TileCellSelector.h>

Inheritance diagram for TileCellSelector:
Collaboration diagram for TileCellSelector:

Public Member Functions

 TileCellSelector (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TileCellSelector ()
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

int Are3FF (std::vector< float > &OptFilterDigits, int OptFilterGain, int ch_type)
 
void printCell (const TileCell *cell)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

unsigned int m_counter
 
unsigned int m_accept
 
unsigned int m_minCell
 
unsigned int m_maxCell
 
unsigned int m_minChan
 
unsigned int m_maxChan
 
unsigned int m_jump
 
unsigned int m_const
 
unsigned int m_overLG
 
unsigned int m_overHG
 
unsigned int m_underLG
 
unsigned int m_underHG
 
unsigned int m_dqerr
 
unsigned int m_dmuerr
 
unsigned int m_warnerr
 
const TileID * m_tileID
 
const TileHWID * m_tileHWID
 
const TileCablingService * m_cabling
 
ToolHandle< ITileBadChanTool > m_tileBadChanTool {this, "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}
 
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey {this, "TileDQstatus", "TileDQstatus", "TileDQstatus key"}
 
ToolHandle< ITileDCSTool > m_tileDCS {this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"}
 
unsigned int m_runNum
 
unsigned int m_lumiBlock
 
unsigned int m_evtNum
 
unsigned int m_evtBCID
 
unsigned int m_tileFlag
 
unsigned int m_tileError
 
std::vector< bool > m_chanBad
 
std::vector< float > m_chanEne
 
std::vector< float > m_chanTime
 
std::vector< float > m_chanDsp
 
std::vector< float > m_chanTDsp
 
std::vector< float > m_chanQua
 
std::vector< bool > m_chanSel
 
std::vector< bool > m_chanToSkip
 
std::vector< bool > m_drawerToSkip
 
bool m_readCells
 
bool m_readRawChannels
 
bool m_readDigits
 
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
 
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
 
float m_minEneCell
 
float m_maxEneCell
 
float m_minEneChan [3] {}
 
float m_maxEneChan [3] {}
 
float m_minTimeCell
 
float m_maxTimeCell
 
float m_minTimeChan [3] {}
 
float m_maxTimeChan [3] {}
 
int m_ptnEneCell
 
int m_ptnEneChan [3] {}
 
int m_ptnTimeCell
 
int m_ptnTimeChan [3] {}
 
int m_selectGain
 
bool m_skipGain [2] {}
 
bool m_bitEneCell [ptnlength] {}
 
bool m_bitTimeCell [ptnlength] {}
 
bool m_bitEneChan [3][ptnlength] {}
 
bool m_bitTimeChan [3][ptnlength] {}
 
float m_secondMaxLevel
 
float m_jumpDeltaHG
 
float m_jumpDeltaLG
 
float m_pedDeltaHG
 
float m_pedDeltaLG
 
int m_constLength
 
int m_minBadDMU
 
int m_maxBadDMU
 
int m_minBadMB
 
bool m_skipEmpty
 
bool m_skipMasked
 
bool m_skipMBTS
 
bool m_checkDCS
 
bool m_checkJumps
 
bool m_checkDMUs
 
bool m_checkOverLG
 
bool m_checkOverHG
 
bool m_checkUnderLG
 
bool m_checkUnderHG
 
float m_overflowLG
 
float m_overflowHG
 
float m_underflowLG
 
float m_underflowHG
 
bool m_checkWarning
 
bool m_checkError
 
bool m_printOnly
 
std::vector< int > m_drawer
 
std::vector< int > m_drawerToCheck
 
std::vector< int > m_chanToCheck
 
int m_maxVerboseCnt
 
std::vector< int > m_nDrawerOff
 
std::string m_infoName
 
const TileInfo * m_tileInfo
 
float m_ADCmaxMinusEps = 0.0F
 
float m_ADCmaskValueMinusEps = 0.0F
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 40 of file TileCellSelector.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileCellSelector()

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

Definition at line 36 of file TileCellSelector.cxx.

37  : AthAlgorithm(name, pSvcLocator)
38  , m_counter(0)
39  , m_accept(0)
40  , m_minCell(0)
41  , m_maxCell(0)
42  , m_minChan(0)
43  , m_maxChan(0)
44  , m_jump(0)
45  , m_const(0)
46  , m_overLG(0)
47  , m_overHG(0)
48  , m_underLG(0)
49  , m_underHG(0)
50  , m_dqerr(0)
51  , m_dmuerr(0)
52  , m_warnerr(0)
53  , m_tileID(0)
54  , m_tileHWID(0)
55  , m_cabling(0)
56  , m_runNum(0)
57  , m_lumiBlock(0)
58  , m_evtNum(0)
59  , m_evtBCID(0)
60  , m_tileFlag(0)
61  , m_tileError(0)
62  , m_readCells(true)
63  , m_readRawChannels(true)
64  , m_readDigits(true)
65  , m_tileInfo(0)
66 {
67 
68  declareProperty( "MinEnergyCell", m_minEneCell = -5000.); // cut on cell energy
69  declareProperty( "MaxEnergyCell", m_maxEneCell = 1000000.); // cut on cell energy
70  declareProperty( "PtnEnergyCell", m_ptnEneCell = 101); // cell energy pattern, accept events only below min (+1), between min-max (+10), above max (+100)
71  declareProperty( "MinEnergyChan", m_minEneChan[0] = -5000.); // cut on channel energy
72  declareProperty( "MaxEnergyChan", m_maxEneChan[0] = 500000.); // cut on channel energy
73  declareProperty( "PtnEnergyChan", m_ptnEneChan[0] = 101); // channel energy pattern
74  declareProperty( "MinEnergyGap", m_minEneChan[1] = -10000.); // cut on channel energy
75  declareProperty( "MaxEnergyGap", m_maxEneChan[1] = 500000.); // cut on channel energy
76  declareProperty( "PtnEnergyGap", m_ptnEneChan[1] = 101); // channel energy pattern
77  declareProperty( "MinEnergyMBTS", m_minEneChan[2] = -10000.); // cut on channel energy
78  declareProperty( "MaxEnergyMBTS", m_maxEneChan[2] = 500000.); // cut on channel energy
79  declareProperty( "PtnEnergyMBTS", m_ptnEneChan[2] = 101); // channel energy pattern
80 
81  declareProperty( "MinTimeCell", m_minTimeCell = -100.); // cut on cell time
82  declareProperty( "MaxTimeCell", m_maxTimeCell = 100.); // cut on cell time
83  declareProperty( "PtnTimeCell", m_ptnTimeCell = 10); // cell time pattern, accept events only below min (+1), between min-max (+10), above max (+100)
84  declareProperty( "MinTimeChan", m_minTimeChan[0] = -100.); // cut on channel time
85  declareProperty( "MaxTimeChan", m_maxTimeChan[0] = 100.); // cut on channel time
86  declareProperty( "PtnTimeChan", m_ptnTimeChan[0] = 10); // channel time pattern
87  declareProperty( "MinTimeGap", m_minTimeChan[1] = -100.); // cut on channel time
88  declareProperty( "MaxTimeGap", m_maxTimeChan[1] = 100.); // cut on channel time
89  declareProperty( "PtnTimeGap", m_ptnTimeChan[1] = 10); // channel time pattern
90  declareProperty( "MinTimeMBTS", m_minTimeChan[2] = -100.); // cut on channel time
91  declareProperty( "MaxTimeMBTS", m_maxTimeChan[2] = 100.); // cut on channel time
92  declareProperty( "PtnTimeMBTS", m_ptnTimeChan[2] = 10); // channel time pattern
93 
94  declareProperty( "SelectGain", m_selectGain = 2); // 0 - select LG only, 1 - HG only, 2 - both gains
95  m_skipGain[TileID::LOWGAIN] = false;
96  m_skipGain[TileID::HIGHGAIN] = false;
97 
98  // pattern - decimal number with up to 5 digits
99  // only values 1(=true) and 0(=false) for every digit are used
100  // digit 0 set to 1 - accept event if value < min
101  // digit 1 set to 1 - accept event if min < value < max
102  // digit 2 set to 1 - accept event if value > max
103  // digit 3 set to 1 - accept ene only if quality is good
104  // or accept time if time != 0
105  // digit 4 set to 1 - accept ene only if quality is bad
106  // or accept time if time == 0
107 
108  declareProperty( "SecondMaxLevel",m_secondMaxLevel = 0.3); // sample below max should be above (max-min)*m_secondMax
109  declareProperty( "JumpDeltaHG", m_jumpDeltaHG = 50.0); // minimal jump in high gain
110  declareProperty( "JumpDeltaLG", m_jumpDeltaLG = 10.0); // minimal jump in low gain
111  declareProperty( "PedDetlaHG", m_pedDeltaHG = 4.1); // max variation of "const" value in high gain
112  declareProperty( "PedDetlaLG", m_pedDeltaLG = 4.1); // max variation of "const" value in low gain
113  declareProperty( "ConstLength", m_constLength = 6); // min number of consecutive samples of the same value
114  declareProperty( "MinBadDMU", m_minBadDMU = 4); // min number of bad DMUs to accept event
115  declareProperty( "MaxBadDMU", m_maxBadDMU = 15); // max number of bad DMUs to accept event
116  declareProperty( "MinBadMB", m_minBadMB = 4); // min number of bad motherboards in a drawer to accept event
117  declareProperty( "SkipEmpty", m_skipEmpty = true); // ignore empty channels in selection or not
118  declareProperty( "SkipMasked", m_skipMasked = true); // ignore masked channels in selection or not
119  declareProperty( "SkipMBTS", m_skipMBTS = true); // ignore MBTS channels in selection or not
120  declareProperty( "CheckDCS", m_checkDCS = true); // additional check for DCS status
121  declareProperty( "DrawerToDump", m_drawer); // for which drawer all channels should be printed
122  declareProperty( "DrawerToCheck",m_drawerToCheck); // for which drawer all checks should be performed
123  declareProperty( "ChannelToCheck",m_chanToCheck); // for which channels all checks should be performed
124 
125  declareProperty( "CheckJumps", m_checkJumps = true); // global flag which allows to swithc on/off all checks in digits
126  declareProperty( "CheckDMUs", m_checkDMUs = true); // global flag which allows to swithc on/off DMU checks
127  declareProperty( "CheckOverLG" ,m_checkOverLG = true); // select events with overflow in low gain
128  declareProperty( "CheckOverHG", m_checkOverHG = false); // select events with overflow in high gain
129  declareProperty( "CheckUnderLG", m_checkUnderLG = false); // select events with underflow in low gain
130  declareProperty( "CheckUnderHG", m_checkUnderHG = false); // select events with underflow in high gain
131  declareProperty( "OverflowLG", m_overflowLG = -0.1); // threshold for overflow in low gain (smaller than ADCmax by this value)
132  declareProperty( "OverflowHG", m_overflowHG = -1.1); // threshold for overflow in high gain (smaller than ADCmax by this value)
133  declareProperty( "UnderflowLG", m_underflowLG = 0.1); // threshold for underflow in low gain
134  declareProperty( "UnderflowHG", m_underflowHG = 2.1); // threshold for underflow in high gain
135 
136  declareProperty( "CheckWarning", m_checkWarning = false); // select events with warning status in TileCal status word
137  declareProperty( "CheckError", m_checkError = false); // select events with error status in TileCal status word
138  declareProperty( "PrintOnly", m_printOnly = false); // only print acccepted events, but do not accept anything
139 
140  declareProperty( "MaxVerboseCnt",m_maxVerboseCnt=20); // max number of verbose output lines about drawer off
141 
142  declareProperty("TileInfoName", m_infoName = "TileInfo");
143 }

◆ ~TileCellSelector()

TileCellSelector::~TileCellSelector ( )
virtual

Definition at line 146 of file TileCellSelector.cxx.

146  {
147 }

Member Function Documentation

◆ Are3FF()

int TileCellSelector::Are3FF ( std::vector< float > &  OptFilterDigits,
int  OptFilterGain,
int  ch_type 
)
private

Definition at line 2111 of file TileCellSelector.cxx.

2111  {
2112  bool allSaturated = true;
2113  int error = 0;
2114 
2115  unsigned int nSamp = OptFilterDigits.size();
2116  if (nSamp) {
2117  float dmin = OptFilterDigits[0];
2118  float dmax = dmin;
2119 
2120  for (unsigned int i = 1; i < nSamp; ++i) {
2121  float dig = OptFilterDigits[i];
2122  if (dig > dmax) dmax = dig;
2123  else if (dig < dmin) dmin = dig;
2124  }
2125  allSaturated = (dmin > m_ADCmaxMinusEps);
2126 
2127  // FIXME:: set these parameters from JobOptions
2128  // FIXME:: move this method to base class
2129  const float epsilon = 4.1; // allow +/- 2 counts fluctuations around const value
2130  const float delta[4] = {29.9, 29.9, 49.9, 99.9}; // jump levels between constLG, constHG, non-constLG, non-constHG
2131  const float level0 = 29.9; // jump from this level to zero is bad
2132  const float level1 = 99.9; // jump from this level to m_tileInfo->ADCmax() is bad
2133  const float level2 = 199.9; // base line at this level is bad
2134  const float delt = std::min(std::min(std::min(delta[0], delta[1]), std::min(delta[2], delta[3])), level0);
2135 
2136  if (!allSaturated && (dmax - dmin) > delt) {
2137  float abovemin = dmax;
2138  float belowmax = dmin;
2139  unsigned int nmin = 0;
2140  unsigned int nmax = 0;
2141  unsigned int pmin = nSamp;
2142  unsigned int pmax = nSamp;
2143  for (unsigned int i = 0; i < nSamp; ++i) {
2144  float smp = OptFilterDigits[i];
2145  if (smp - dmin < epsilon) {
2146  ++nmin;
2147  pmin = i;
2148  }
2149  if (dmax - smp < epsilon) {
2150  ++nmax;
2151  pmax = i;
2152  }
2153  if (smp < abovemin && smp > dmin) {
2154  abovemin = smp;
2155  }
2156  if (smp > belowmax && smp < dmax) {
2157  belowmax = smp;
2158  }
2159  }
2160 
2161  if (abovemin != dmax || belowmax != dmin) { // more than two different values
2162  gain += 2; // shift index by 2, i.e. use thresholds for non-const levels
2163  }
2164 
2165  if (dmin < 0.01 && dmax > m_ADCmaxMinusEps) { // jump from zero to saturation
2166  error = 1;
2167  } else if (dmin < 0.01 && abovemin > level0 && nmin > 1) { // at least two samples at zero, others - above pedestal
2168  error = 2;
2169  } else if (dmax > m_ADCmaxMinusEps && belowmax < level1 && nmax > 1) { // at least two saturated. others - close to pedestal
2170  error = 3;
2171  } else if (dmin>level2 && (gain==0 || ch_type<2) ) { // baseline above threshold is bad
2172  error = 9; // but should not apply that to MBTS
2173  } else if (nmax+nmin==nSamp && (dmax-dmin) > delta[gain]) {
2174  if (nmax>1 && nmin>1) { // at least 2 samples at two distinct levels
2175  error = 4;
2176  } else if (nmax==1) {
2177  if (pmax>0 && pmax<nSamp-1) { // jump up in one sample, but not at the edge
2178  error = 5;
2179  }
2180  } else if (nmin==1) { // jump down in one sample
2181  error = 6;
2182  }
2183  }
2184  if (!error && (dmax - dmin) > delta[gain]) {
2185  float secondMax = (dmax - dmin) * m_secondMaxLevel;
2186  if (pmax > 0 && pmax < nSamp - 1
2187  && std::max(OptFilterDigits[pmax - 1], OptFilterDigits[pmax + 1]) < dmin + secondMax) {
2188 
2189  error = 7; // jump up in one sample in the middle. which is much higher than all others
2190  } else if (pmin > 0 && pmin < nSamp - 1
2191  && std::min(OptFilterDigits[pmin - 1], OptFilterDigits[pmin + 1]) > dmax - secondMax) {
2192 
2193  error = 8; // jump down in one sample. which is much lower than all others
2194  }
2195  }
2196  }
2197  }
2198 
2199  if (allSaturated)
2200  return 99;
2201  else
2202  return error;
2203 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode TileCellSelector::execute ( )
overridevirtual

Definition at line 375 of file TileCellSelector.cxx.

375  {
376  //ATH_MSG_DEBUG ("execute()");
377 
378  const EventContext& ctx = Gaudi::Hive::currentContext();
379 
380  ++m_counter;
381 
382  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
383  if ( eventInfo.isValid() ) {
384  m_runNum = eventInfo->runNumber();
385  m_lumiBlock = eventInfo->lumiBlock();
386  m_evtNum = eventInfo->eventNumber();
387  m_evtBCID = eventInfo->bcid();
388  m_tileFlag = eventInfo->eventFlags(EventInfo::Tile);
389  m_tileError = eventInfo->errorState(EventInfo::Tile);
390  } else {
391  m_runNum = 0;
392  m_evtNum = 0;
393  m_lumiBlock = 0;
394  m_evtBCID = 0;
395  m_tileFlag = 0;
396  m_tileError = 0;
397  }
398 
399  std::ostringstream evState;
400  evState << "Run "<< std::setw(6) << m_runNum
401  <<" LB "<< std::setw(4) << m_lumiBlock
402  <<" Evt "<< std::setw(9) << m_evtNum
403  <<" ErrState " << m_tileError
404  <<" Flags 0x" << std::hex << m_tileFlag << std::dec;
405 
406  std::ostringstream evtnum;
407  evtnum << "Run "<< std::setw(6) << m_runNum
408  <<" LB "<< std::setw(4) << m_lumiBlock
409  <<" Evt "<< std::setw(9) << m_evtNum
410  <<" BCID "<< std::setw(4) << m_evtBCID;
411 
412  std::ostringstream nevtnum;
413  nevtnum << evtnum.str()
414  <<" nevt "<< std::setw(6) << m_counter;
415 
416  bool emptyBad = true;
417  bool badFromCell = false;
418  m_chanBad.clear();
419  m_chanBad.resize(1+TileHWID::NOT_VALID_HASH,true);
420  m_chanEne.clear();
421  m_chanEne.resize(1+TileHWID::NOT_VALID_HASH,0.0);
422  m_chanTime.clear();
423  m_chanTime.resize(1+TileHWID::NOT_VALID_HASH,0.0);
424  m_chanQua.clear();
425  m_chanQua.resize(1+TileHWID::NOT_VALID_HASH,0.0);
426  m_chanSel.clear();
427  m_chanSel.resize(1+TileHWID::NOT_VALID_HASH,false);
428 
429  IdContext chan_context = m_tileHWID->channel_context();
430  IdentifierHash hash;
431  for (size_t i=0; i<m_drawer.size(); ++i) {
432  HWIdentifier drawer_id = m_tileHWID->drawer_id(m_drawer[i]);
433  HWIdentifier ch_id = m_tileHWID->channel_id(drawer_id,0);
434  m_tileHWID->get_hash(ch_id, hash, &chan_context);
435  auto itr = m_chanSel.begin() + hash;
436  std::fill(itr,itr+48,true);
437  }
438 
439  bool statusOk = (m_checkWarning && m_tileError == EventInfo::Warning) ||
440  (m_checkError && m_tileError == EventInfo::Error);
441  if (statusOk) {
442  ++m_warnerr;
443 
444  using namespace boost::local_time;
445  using namespace boost::posix_time;
446  static const time_zone_ptr gva_tz(new posix_time_zone((std::string)"CET+01CEST01:00:00,M3.5.0/02:00:00,M10.5.0/03:00:00"));
447  local_date_time gva_time(from_time_t(eventInfo->timeStamp()),gva_tz);
448  evState << " " << gva_time << " ";
449 
450 
451  const char * part[5] = { "UNK", "LBA", "LBC", "EBA", "EBC" };
452  if (m_tileError == EventInfo::Warning) {
453  int dn = (m_tileFlag >> 16) & 0xF;
454  int n1 = (m_tileFlag >> 20) & 0x3F;
455  int n2 = (n1 + dn - 1) % 64;
456  int rr = ((m_tileFlag >> 26) & 0x3) + 1;
457  evState << " " << part[rr] <<std::setw(2)<<std::setfill('0')<<n1+1
458  << " - " << part[rr] <<std::setw(2)<<std::setfill('0')<<n2+1
459  << " " << dn << " consec bad ";
460  }
461  else if (m_tileError == EventInfo::Error) {
462  int dn = (m_tileFlag >> 16) & 0xF;
463  int p0 = m_tileFlag & 0xF; // sends any data above threshold
464  int p1 = (m_tileFlag >> 20) & 0xF; // 16 drawers masked
465  int p2 = (m_tileFlag >> 24) & 0xF; // 16 drawers off
466  int pp = 1;
467  for (int rr = 1; rr < 5; ++rr) {
468  if ((p2 & pp) || (p1 & pp)) {
469  evState << " " << part[rr];
470  if (p2 & pp) {
471  if (p0 & pp) evState << " off";
472  else evState << " OFF";
473  }
474  if (p1 & pp) {
475  if (p0 & pp) evState << " mask";
476  else evState << " MASK";
477  }
478  }
479  pp <<= 1;
480  }
481  evState << " " << dn << " consec bad ";
482  }
483 
484  if (m_checkDCS) {
485  int n1 = -1;
486  int n2 = -1;
487  int dn = 0;
488  int rr = 0;
489  int m1 = -1;
490  int m2 = -1;
491  int dm = -1;
492  std::vector<int> allmod;
493  std::vector<int> consec;
494  for (int ros = 1; ros < 5; ++ros) {
495  int drmax = 65;
496  for (int dr = 0; dr < drmax; ++dr) {
497  int drawer = dr % 64;
498  if (m_tileDCS->getDCSStatus(ros, drawer) == TileDCSState::ALERT_DRAWER) {
499  if (m1 < 0) m1 = dr;
500  m2 = dr;
501  if (dr < 64) allmod.push_back((ros << 8) + dr);
502  } else if (m1 >= 0) {
503  dm = m2 - m1 + 1;
504  if (m1 == 0) drmax += dm;
505  if (dm > dn) {
506  n1 = m1;
507  n2 = m2;
508  dn = dm;
509  rr = ros;
510  consec.clear();
511  consec.push_back((ros << 8) + m1);
512  } else if (dm == dn) {
513  if (m1 < 64) consec.push_back((ros << 8) + m1);
514  }
515  m1 = m2 = -1;
516  }
517  }
518  }
519  evState << " DCS " << allmod.size() << " off ";
520  if (dn > 1) {
521  evState << dn;
522  if (consec.size() > 1) evState << "*" << (consec.size());
523  evState << " consec "
524  << part[rr] << std::setw(2) << std::setfill('0') << (n1 % 64) + 1 << " - "
525  << part[rr] << std::setw(2) << std::setfill('0') << (n2 % 64) + 1 << " ";
526  n1 += (rr << 8);
527  n2 += (rr << 8);
528  for (size_t n = 1; n < consec.size(); ++n) {
529  m1 = consec[n];
530  m2 = m1 + dn - 1;
531  evState << part[m1 >> 8] << std::setw(2) << std::setfill('0') << (m1 % 64) + 1 << " - "
532  << part[m2 >> 8] << std::setw(2) << std::setfill('0') << (m2 % 64) + 1 << " ";
533  for (size_t m = 0; m < allmod.size(); ++m) {
534  int mm = allmod[m];
535  if (mm >= m1 && mm <= m2) {
536  allmod[m] += n1 - m1;
537  }
538  }
539  }
540  } else {
541  n1 = n2 = dn = 0;
542  }
543  if (allmod.size() > (size_t) dn) {
544  for (size_t m = 0; m < allmod.size(); ++m) {
545  int mm = allmod[m];
546  if (!(mm >= n1 && mm <= n2)) {
547  evState << part[mm >> 8] << std::setw(2) << std::setfill('0') << (mm % 64) + 1 << " ";
548  }
549  }
550  }
551  }
552 
553  ATH_MSG_DEBUG (evState.str() << " accepted");
554  }
555 
556  int rawdata = -1;
557  const TileCell* cellminCh = 0;
558  const TileCell* cellmaxCh = 0;
559  const TileCell* tcellminCh = 0;
560  const TileCell* tcellmaxCh = 0;
561 
562  if (m_readCells) {
563 
564  // Get Calo cell container
565  SG::ReadHandle<CaloCellContainer> cellContainer(m_cellContainerKey);
566 
567  if (!cellContainer.isValid()) {
568 
569  ATH_MSG_WARNING("Unable to read CaloCellContainer from EventStore, disable reading of this container");
570  m_readCells = false;
571 
572  } else {
573 
574  float emin = 0.;
575  float emax = 0.;
576  float tmin = 0.;
577  float tmax = 0.;
578  float chmin = 0.;
579  float chmax = 0.;
580  float tcmin = 0.;
581  float tcmax = 0.;
582  const TileCell* cellmin = 0;
583  const TileCell* cellmax = 0;
584  const TileCell* tcellmin = 0;
585  const TileCell* tcellmax = 0;
586 
587  // special case - check overflow here if digits container is not available
588  // should be careful here, because in TileCell overflow bit is set to 1
589  // both for overflow and underflow and underflow is HG are very often in gap cells
590  // also, overflow in HG might be masked if quality is too bad, so we'll not select all overflows...
591  // that's why only overflow in LG are checked
592  bool checkOver = (m_checkOverLG && m_digitsContainerKey.key().empty());
593 
594  for (const CaloCell* cell : *cellContainer) {
595 
596  Identifier id = cell->ID();
597  if ( m_tileID->is_tile(id) ) {
598  const TileCell* tile_cell = dynamic_cast<const TileCell*> (cell);
599  if (tile_cell==0) continue;
600  const CaloDetDescrElement * caloDDE = cell->caloDDE();
601  IdentifierHash hash1 = caloDDE->onl1();
602  IdentifierHash hash2 = caloDDE->onl2();
603  if ( m_chanToSkip[hash1] && m_chanToSkip[hash2] ) continue;
604  int ch_type = (hash2 == TileHWID::NOT_VALID_HASH) ? 1 : 0;
605  if (rawdata < 0) {
606  rawdata = (tile_cell->qbit1() & TileCell::MASK_CMPC) ? 0 : 1;
607  }
608 
609  bool bad1 = tile_cell->badch1();
610  bool bad2 = tile_cell->badch2();
611  float ene1 = tile_cell->ene1();
612  float ene2 = tile_cell->ene2();
613  float time1 = tile_cell->time1();
614  float time2 = tile_cell->time2();
615  m_chanBad[hash1] = bad1;
616  m_chanBad[hash2] = bad2;
617  m_chanEne[hash1] = ene1;
618  m_chanEne[hash2] = ene2;
619  m_chanTime[hash1] = time1;
620  m_chanTime[hash2] = time2;
621  m_chanQua[hash1] = tile_cell->qual1();
622  m_chanQua[hash2] = tile_cell->qual2();
623 
624  float ene = tile_cell->energy();
625  bool eneOk = false;
626  if (ene < m_minEneCell) {
627  eneOk = m_bitEneCell[0];
628  } else if (ene > m_maxEneCell) {
629  eneOk = m_bitEneCell[2];
630  } else {
631  eneOk = m_bitEneCell[1];
632  }
633 
634  if (eneOk) {
635  if (bad1 && bad2) {
636  if (m_bitEneCell[3]) eneOk = false; // request good cells only, but cell is bad
637  } else {
638  if (m_bitEneCell[4]) eneOk = false; // request bad cells only, but cell is good
639  }
640  }
641 
642  float time = tile_cell->time();
643  bool timeOk = false;
644  if (time < m_minTimeCell) {
645  timeOk = m_bitTimeCell[0];
646  } else if (time > m_maxTimeCell ) {
647  timeOk = m_bitTimeCell[2];
648  } else {
649  timeOk = m_bitTimeCell[1];
650  }
651 
652  if (timeOk) {
653  if (time != 0.) {
654  if (m_bitTimeCell[4]) timeOk = false; // request time==0 only, but time!=0
655  } else {
656  if (m_bitTimeCell[3]) timeOk = false; // request time!=0 only, but time==0
657  }
658  }
659 
660  if (timeOk && eneOk) {
661 
662  ATH_MSG_VERBOSE( evtnum.str()
663  << " cell " << std::left << std::setw(14) << m_tileID->to_string(id,-2)
664  << " ene = " << ene << " time = " << time);
665 
666  m_chanSel[hash1] = true;
667  m_chanSel[hash2] = true;
668 
669  if (ene < emin) {
670  emin = ene;
671  cellmin = tile_cell;
672  } else if (ene > emax) {
673  emax = ene;
674  cellmax = tile_cell;
675  }
676 
677  if (time<tmin) {
678  tmin = time;
679  tcellmin = tile_cell;
680  }
681  else if (time>tmax) {
682  tmax = time;
683  tcellmax = tile_cell;
684  }
685  }
686 
687  if ( !(bad1 && bad2) ) {
688 
689  bool ene1Ok = false;
690  bool time1Ok = false;
691 
692  if ( !(bad1 || m_skipGain[tile_cell->gain1()]) ) {
693  if (time1 < m_minTimeChan[ch_type] ) {
694  time1Ok = m_bitTimeChan[ch_type][0];
695  } else if (time1 > m_maxTimeChan[ch_type] ) {
696  time1Ok = m_bitTimeChan[ch_type][2];
697  } else {
698  time1Ok = m_bitTimeChan[ch_type][1];
699  }
700 
701  if (ene1 < m_minEneChan[ch_type] ) {
702  ene1Ok = m_bitEneChan[ch_type][0];
703  } else if (ene1 > m_maxEneChan[ch_type] ) {
704  ene1Ok = m_bitEneChan[ch_type][2];
705  } else {
706  ene1Ok = m_bitEneChan[ch_type][1];
707  }
708 
709  if (ene1Ok) {
710  if (m_bitEneChan[ch_type][4]) ene1Ok = false; // request bad chan only, but chan is good
711  }
712 
713  if (time1Ok) {
714  if (time1 != 0.) {
715  if (m_bitTimeChan[ch_type][4]) time1Ok = false; // request time==0 only, but time!=0
716  } else {
717  if (m_bitTimeChan[ch_type][3]) time1Ok = false; // request time!=0 only, but time==0
718  }
719  }
720  }
721 
722  bool ene2Ok = false;
723  bool time2Ok = false;
724 
725  if ( !(bad2 || m_skipGain[tile_cell->gain2()]) ) {
726  if (ene2 < m_minEneChan[ch_type] ) {
727  ene2Ok = m_bitEneChan[ch_type][0];
728  } else if (ene2 > m_maxEneChan[ch_type] ) {
729  ene2Ok = m_bitEneChan[ch_type][2];
730  } else {
731  ene2Ok = m_bitEneChan[ch_type][1];
732  }
733 
734  if (time2 < m_minTimeChan[ch_type] ) {
735  time2Ok = m_bitTimeChan[ch_type][0];
736  } else if (time2 > m_maxTimeChan[ch_type] ) {
737  time2Ok = m_bitTimeChan[ch_type][2];
738  } else {
739  time2Ok = m_bitTimeChan[ch_type][1];
740  }
741 
742  if (ene2Ok) {
743  if (m_bitEneChan[ch_type][4]) ene2Ok = false; // request bad chan only, but chan is good
744  }
745 
746  if (time2Ok) {
747  if (time2 != 0.) {
748  if (m_bitTimeChan[ch_type][4]) time2Ok = false; // request time==0 only, but time!=0
749  } else {
750  if (m_bitTimeChan[ch_type][3]) time2Ok = false; // request time!=0 only, but time==0
751  }
752  }
753  }
754 
755  bool over1=false;
756  bool over2=false;
757  if (checkOver) {
758  over1 = ( (!bad1) && (tile_cell->qbit1() & TileCell::MASK_OVER) && tile_cell->gain1()==TileID::LOWGAIN);
759  over2 = ( (!bad2) && (tile_cell->qbit2() & TileCell::MASK_OVER) && tile_cell->gain2()==TileID::LOWGAIN);
760  }
761 
762  if ((ene1Ok && time1Ok) || over1) {
763 
764  ATH_MSG_VERBOSE( evtnum.str()
765  << " cell " << std::left << std::setw(14) << m_tileID->to_string(id,-2)
766  << " ch_ene1 = " << ene1 << " ch_t1 = " << time1
767  << ((over1)?" overflow":""));
768 
769  m_chanSel[hash1] = true;
770  m_chanSel[hash2] = true;
771 
772  if (ene1 < chmin) {
773  chmin = ene1;
774  cellminCh = tile_cell;
775  } else if (ene1 > chmax) {
776  chmax = ene1;
777  cellmaxCh = tile_cell;
778  }
779 
780  if (time1 < tcmin) {
781  tcmin = time1;
782  tcellminCh = tile_cell;
783  } else if (time1 > tcmax) {
784  tcmax = time1;
785  tcellmaxCh = tile_cell;
786  }
787  }
788 
789  if ((ene2Ok && time2Ok) || over2) {
790 
791  ATH_MSG_VERBOSE( evtnum.str()
792  << " cell " << std::left << std::setw(14) << m_tileID->to_string(id,-2)
793  << " ch_ene2 = " << ene2 << " ch_t2 = " << time2
794  << ((over2)?" overflow":""));
795 
796  m_chanSel[hash1] = true;
797  m_chanSel[hash2] = true;
798 
799  if (ene2 < chmin) {
800  chmin = ene2;
801  cellminCh = tile_cell;
802  } else if (ene2 > chmax) {
803  chmax = ene2;
804  cellmaxCh = tile_cell;
805  }
806 
807  if (time2 < tcmin) {
808  tcmin = time2;
809  tcellminCh = tile_cell;
810  } else if (time2 > tcmax) {
811  tcmax = time2;
812  tcellmaxCh = tile_cell;
813  }
814  }
815 
816  }
817  }
818  }
819 
820  if (tcellmin && tcellmin != cellmin && tcellmin != cellmax) {
821  ATH_MSG_DEBUG( nevtnum.str()
822  << " cell " << std::left << std::setw(14) << m_tileID->to_string(tcellmin->ID(),-2)
823  << " ene = " << tcellmin->energy()
824  << " tmin = " << tcellmin->time());
825  }
826  if (tcellmax && tcellmax != cellmin && tcellmax != cellmax) {
827  ATH_MSG_DEBUG( nevtnum.str()
828  << " cell " << std::left << std::setw(14) << m_tileID->to_string(tcellmax->ID(),-2)
829  << " ene = " << tcellmax->energy()
830  << " tmax = " << tcellmax->energy());
831  }
832 
833  if (tcellminCh && tcellminCh != cellminCh && tcellminCh != cellmaxCh) {
834  ATH_MSG_DEBUG( nevtnum.str()
835  << " cell " << std::left << std::setw(14) << m_tileID->to_string(tcellminCh->ID(),-2)
836  << " ch_ene = " << tcellminCh->ene1() << " " << tcellminCh->ene2()
837  << " ch_tmin = " << tcellminCh->time1() << " " << tcellminCh->time2());
838  }
839  if (tcellmaxCh && tcellmaxCh != cellminCh && tcellmaxCh != cellmaxCh) {
840  ATH_MSG_DEBUG( nevtnum.str()
841  << " cell " << std::left << std::setw(14) << m_tileID->to_string(tcellmaxCh->ID(),-2)
842  << " ch_ene = " << tcellmaxCh->ene1() << " " << tcellmaxCh->ene2()
843  << " ch_tmax = " << tcellmaxCh->time1() << " " << tcellmaxCh->time2());
844  }
845 
846  if (cellmin) {
847  ++m_minCell;
848  statusOk = true;
849  const char * tit = (tcellmin == cellmin) ? " tmin = ": ((tcellmax == cellmin) ? " tmax = ": " t = ");
850  if (cellminCh!=cellmin) {
851  ATH_MSG_DEBUG( nevtnum.str()
852  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellmin->ID(),-2)
853  << " emin = " << emin
854  << tit << cellmin->time()
855  << " accepted");
856 
857  } else {
858  ATH_MSG_DEBUG( nevtnum.str()
859  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellmin->ID(),-2)
860  << " emin = " << emin
861  << " ch_emin = " << chmin
862  << tit << cellmin->time()
863  << " accepted");
864  }
865  }
866 
867  if (cellminCh) {
868  ++m_minChan;
869  statusOk = true;
870  const char * tit = (tcellminCh == cellminCh) ? " tmin = ": ((tcellmaxCh == cellminCh) ? " tmax = ": " t = ");
871  if (cellminCh!=cellmin) {
872  ATH_MSG_DEBUG( nevtnum.str()
873  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellminCh->ID(),-2)
874  << " ch_emin = " << chmin
875  << tit << cellminCh->time()
876  << " accepted");
877  }
878  }
879 
880  if (cellmax) {
881  ++m_maxCell;
882  statusOk = true;
883  const char * tit = (tcellmin == cellmax) ? " tmin = ": ((tcellmax == cellmax) ? " tmax = ": " t = ");
884  if (cellmaxCh!=cellmax) {
885  ATH_MSG_DEBUG( nevtnum.str()
886  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellmax->ID(),-2)
887  << " emax = " << emax
888  << tit << cellmax->time()
889  << " accepted");
890 
891  } else {
892  ATH_MSG_DEBUG( nevtnum.str()
893  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellmax->ID(),-2)
894  << " emax = " << emax
895  << " ch_emax = " << chmax
896  << tit << cellmax->time()
897  << " accepted");
898  }
899  }
900 
901  if (cellmaxCh) {
902  ++m_maxChan;
903  statusOk = true;
904  const char * tit = (tcellminCh == cellmaxCh) ? " tmin = ": ((tcellmaxCh == cellmaxCh) ? " tmax = ": " t = ");
905  if (cellmaxCh!=cellmax) {
906  ATH_MSG_DEBUG( nevtnum.str()
907  << " cell " << std::left << std::setw(14) << m_tileID->to_string(cellmaxCh->ID(),-2)
908  << " ch_emax = " << chmax
909  << tit << cellmaxCh->time()
910  << " accepted");
911  }
912  }
913 
914  emptyBad = false;
915  badFromCell = true;
916  }
917  }
918 
919  const TileDQstatus* DQstatus(0);
920 
921  if (m_readRawChannels) {
922 
923  // Get Tile RawChannel container
924  SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(m_rawChannelContainerKey);
925 
926  if ( !rawChannelContainer.isValid() ) {
927  ATH_MSG_WARNING("Unable to read TileRawChannelContainer from EventStore, disable reading of this container");
928  m_readRawChannels = false;
929 
930  } else {
931 
932  float chmin = 0; // m_minEneChan[0];
933  float chmax = 0; // m_maxEneChan[0];
934  float tcmin = 0.;
935  float tcmax = 0.;
936  const TileRawChannel* minCh = 0;
937  const TileRawChannel* maxCh = 0;
938  const TileRawChannel* tminCh = 0;
939  const TileRawChannel* tmaxCh = 0;
940  TileRawChannelUnit::UNIT rChUnit = rawChannelContainer->get_unit();
941  bool allowAmpCheck = ( ( rChUnit == TileRawChannelUnit::MegaElectronVolts || // allow MeV only as units
942  rChUnit == TileRawChannelUnit::OnlineMegaElectronVolts ) ) ;
943  bool fillChanEne = ( !m_readCells && allowAmpCheck ); // use amplitude from channel if cell container was not checked
944  if (!fillChanEne) {
945  m_chanDsp.clear();
946  m_chanDsp.resize(1+TileHWID::NOT_VALID_HASH,0.0);
947  m_chanTDsp.clear();
948  m_chanTDsp.resize(1+TileHWID::NOT_VALID_HASH,0.0);
949  }
950 
951  if (rChUnit >= TileRawChannelUnit::OnlineADCcounts)
952  DQstatus = SG::makeHandle (m_dqStatusKey, ctx).get();
953  else
954  rawdata = 0;
955 
956  IdContext chan_context = m_tileHWID->channel_context();
957  IdentifierHash hash;
958  int index=0, pmt;
959 
960  int nbadMax = 0;
961  int nbadMBMax = 0;
962  const TileRawChannelCollection * collMax = 0;
963  const TileRawChannelCollection * collMBMax = 0;
964 
965  bool someDQerrors = false;
966 
967  for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
968 
969  int frag = rawChannelCollection->identify();
970  bool eb = (frag > 0x2ff);
971  bool ebsp = (frag == 0x30e || frag == 0x411);
972 
973  int ros = frag >> 8;
974  int drawer = frag & 0x3F;
975  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
976  if ( m_drawerToSkip[drawerIdx] ) continue;
977 
978  int chMBTS = -1;
979  if (eb) {
980  for (int ch: {12,4,0}) {
981  m_cabling->h2s_cell_id_index(ros,drawer,ch,index,pmt);
982  if (index == -2) {
983  chMBTS = ch;
984  break;
985  }
986  }
987  }
988 
989  HWIdentifier ch_id = m_tileHWID->channel_id(ros,drawer,0);
990  m_tileHWID->get_hash(ch_id, hash, &chan_context);
991  int hashNext = index = (int)hash + 48; // hash ID of the channel after current drawer
992 
993  // all error words contains information in last 16 bits only
994  // but they are stored in collection as 32 bit numbers
995  uint32_t RODBCID = rawChannelCollection->getRODBCID();
996  uint32_t DSPBCID = rawChannelCollection->getFragDSPBCID();
997  uint32_t GlobalCRCErr = rawChannelCollection->getFragGlobalCRC() & 0x1;
998  uint32_t FE_DMUmask = rawChannelCollection->getFragFEChipMask();
999  uint32_t ROD_DMUmask = rawChannelCollection->getFragRODChipMask();
1000  uint32_t BCIDErr = rawChannelCollection->getFragBCID();
1001  uint32_t MemoryParityErr = rawChannelCollection->getFragMemoryPar();
1002  uint32_t HeaderFormatErr = rawChannelCollection->getFragHeaderBit();
1003  uint32_t HeaderParityErr = rawChannelCollection->getFragHeaderPar();
1004  uint32_t SampleFormatErr = rawChannelCollection->getFragSampleBit();
1005  uint32_t SampleParityErr = rawChannelCollection->getFragSamplePar();
1006  uint32_t SingleStrobeErr = rawChannelCollection->getFragSstrobe();
1007  uint32_t DoubleStrobeErr = rawChannelCollection->getFragDstrobe();
1008 
1009  if (RODBCID!=0 && RODBCID != m_evtBCID ) {
1010  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1011  ATH_MSG_VERBOSE( evtnum.str()
1012  << " drw " << drwname(rawChannelCollection->identify())
1013  << " ROD BCID " << RODBCID << " is wrong - skipping");
1014 
1015  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1016  ATH_MSG_VERBOSE( nevtnum.str()
1017  << " suppressing further messages about drawer 0x" << std::hex << rawChannelCollection->identify()
1018  << std::dec << " being bad");
1019  }
1020  someDQerrors = true;
1021  continue;
1022  }
1023 
1024  if (DSPBCID >= 0x7FFF
1025  && GlobalCRCErr
1026  && FE_DMUmask == 0xFFFF
1027  && ROD_DMUmask == 0xFFFF
1028  && BCIDErr == 0xFFFF
1029  && MemoryParityErr == 0xFFFF
1030  && HeaderFormatErr == 0xFFFF
1031  && HeaderParityErr == 0xFFFF
1032  && SampleFormatErr == 0xFFFF
1033  && SampleParityErr == 0xFFFF
1034  && SingleStrobeErr == 0xFFFF
1035  && DoubleStrobeErr == 0xFFFF) {
1036 
1037  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1038  ATH_MSG_VERBOSE( evtnum.str()
1039  << " drw " << drwname(rawChannelCollection->identify())
1040  << " is OFF - skipping");
1041 
1042  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1043  ATH_MSG_VERBOSE( nevtnum.str()
1044  << " suppressing further messages about drawer 0x" << std::hex
1045  << rawChannelCollection->identify()
1046  << std::dec << " being bad");
1047  }
1048  continue;
1049  }
1050 
1051  if (DSPBCID == 0
1052  && GlobalCRCErr == 0
1053  && FE_DMUmask == 0
1054  && ROD_DMUmask == 0
1055  && BCIDErr == 0
1056  && MemoryParityErr == 0
1057  && HeaderFormatErr == 0
1058  && HeaderParityErr == 0
1059  && SampleFormatErr == 0
1060  && SampleParityErr == 0
1061  && SingleStrobeErr == 0
1062  && DoubleStrobeErr == 0) {
1063 
1064  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1065  ATH_MSG_VERBOSE( evtnum.str()
1066  << " drw " << drwname(rawChannelCollection->identify())
1067  << " is MISSING - skipping");
1068 
1069  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1070  ATH_MSG_VERBOSE( nevtnum.str()
1071  << " suppressing further messages about drawer 0x" << std::hex
1072  << rawChannelCollection->identify() << std::dec << " being bad");
1073  }
1074  continue;
1075  }
1076 
1077  if (GlobalCRCErr) {
1078  GlobalCRCErr = 0xFFFF; // global error - all wrong
1079  if (m_maxBadDMU<16) {
1080  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1081  ATH_MSG_VERBOSE( evtnum.str()
1082  << " drw " << drwname(rawChannelCollection->identify())
1083  << " global CRC error - skipping");
1084 
1085  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1086  ATH_MSG_VERBOSE( nevtnum.str()
1087  << " suppressing further messages about drawer 0x" << std::hex
1088  << rawChannelCollection->identify() << std::dec << " being bad");
1089  }
1090  someDQerrors = true;
1091  continue;
1092  }
1093  }
1094 
1095  if (HeaderFormatErr || HeaderParityErr || SampleFormatErr || SampleParityErr ) {
1096  FE_DMUmask = 0xFFFF; // can not trust FE mask, assume that all DMUs are good
1097  } else {
1098  if (eb) { // extended barrel
1099  if (ebsp) FE_DMUmask<<=1; // shift by one DMU in EBA15 EBC18
1100  FE_DMUmask = (FE_DMUmask & 0xFF) | ((FE_DMUmask & 0xF00)<<2); // shift upper half by two DMUs
1101  }
1102  }
1103 
1104  FE_DMUmask = ~FE_DMUmask & 0xFFFF; // inversion for FE CRC
1105  ROD_DMUmask = ~ROD_DMUmask & 0xFFFF; // inversion for ROD CRC
1106 
1107  if (BCIDErr & 0x2) { // DMU1 (second DMU) is bad - can not trust others
1108  BCIDErr = 0xFFFF; // assume that all DMUs are bad
1109  if (m_maxBadDMU < 16) {
1110  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1111  ATH_MSG_VERBOSE( evtnum.str()
1112  << " drw " << drwname(rawChannelCollection->identify())
1113  << " BCID in DMU1 is bad - skipping");
1114 
1115  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1116  ATH_MSG_VERBOSE( nevtnum.str()
1117  << " suppressing further messages about drawer 0x"
1118  << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1119  }
1120  someDQerrors = true;
1121  continue;
1122  }
1123 
1124  } else {
1125  // additional check if DQ frag BCID is the same as event BCID
1126  if ( DSPBCID!=0xDEAD && DSPBCID!=m_evtBCID ) { // DSP BCID doesn't match! all wrong
1127  BCIDErr = 0xFFFF;
1128  if (m_maxBadDMU < 16) {
1129  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1130  ATH_MSG_VERBOSE( evtnum.str()
1131  << " drw " << drwname(rawChannelCollection->identify())
1132  << " DSP BCID is wrong - skipping");
1133 
1134  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1135  ATH_MSG_VERBOSE( nevtnum.str()
1136  << " suppressing further messages about drawer 0x"
1137  << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1138  }
1139  someDQerrors = true;
1140  continue;
1141  }
1142  }
1143  }
1144 
1145  uint32_t error = GlobalCRCErr | FE_DMUmask | ROD_DMUmask | BCIDErr | MemoryParityErr |
1146  HeaderFormatErr | HeaderParityErr | SampleFormatErr | SampleParityErr;
1147 
1148  if (error==0xFFFF && m_maxBadDMU<16) {
1149  if (m_nDrawerOff[drawerIdx] < m_maxVerboseCnt) {
1150  ATH_MSG_VERBOSE( evtnum.str()
1151  << " drw " << drwname(rawChannelCollection->identify())
1152  << " whole drawer is bad - skipping");
1153 
1154  if (++m_nDrawerOff[drawerIdx] == m_maxVerboseCnt)
1155  ATH_MSG_VERBOSE( nevtnum.str()
1156  << " suppressing further messages about drawer 0x"
1157  << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1158  }
1159  someDQerrors = true;
1160  continue;
1161  }
1162 
1163  // no global error detected - wait m_max_verbose_cnt good events and eventually enable error messages again
1164  if (m_nDrawerOff[drawerIdx]>=m_maxVerboseCnt) {
1165  if (++m_nDrawerOff[drawerIdx] == 2*m_maxVerboseCnt) {
1166  m_nDrawerOff[drawerIdx] = 0;
1167  ATH_MSG_VERBOSE( nevtnum.str()
1168  << " enabling messages about drawer 0x" << std::hex
1169  << rawChannelCollection->identify()
1170  << std::dec << " being bad after " << m_maxVerboseCnt << " good events");
1171  }
1172  }
1173 
1174  uint32_t errMB = BCIDErr;
1175  if (eb) { // do not count non-existing DMUs in EB
1176  if (ebsp) {
1177  errMB &= 0x3cfe;
1178  } else {
1179  errMB &= 0x3cff;
1180  }
1181  }
1182  int nbadMB = 0;
1183  while (errMB) {
1184  if (errMB & 0xF) ++nbadMB;
1185  errMB >>= 4;
1186  }
1187  someDQerrors = (nbadMB >= m_minBadMB);
1188  if (nbadMB > nbadMBMax) {
1189  nbadMBMax = nbadMB;
1190  collMBMax = rawChannelCollection;
1191  }
1192 
1193  int nerr = 0;
1194  for (uint32_t i = 0x8000; i != 0; i >>= 1) {
1195  if (error&i) {
1196  ++nerr;
1197  index-=3;
1198  } else {
1199  if (emptyBad && nbadMB < 4) {
1200  m_chanBad[--index] = false;
1201  m_chanBad[--index] = false;
1202  m_chanBad[--index] = false;
1203  } else {
1204  index -= 3;
1205  }
1206  }
1207  }
1208  //if (chMBTS>=0) m_chanBad[index+chMBTS] = true; // ignore completely MBTS channel
1209  int nbad = ((ebsp) ? nerr-5 : ((eb) ? nerr-4 : nerr));
1210 
1211  if (nbad >= m_minBadDMU && nerr <= m_maxBadDMU) {
1212  someDQerrors = true;
1213  if (nbad > nbadMax) {
1214  nbadMax = nbad;
1215  collMax = rawChannelCollection;
1216  }
1217  }
1218  if (someDQerrors) { // will print later samples for all channels in a drawer
1219  for ( ; index<hashNext; ++index) { // but if drawer was completely bad, this loop will be skipped
1220  m_chanSel[index] = true;
1221  }
1222  }
1223 
1224  if (allowAmpCheck || emptyBad) {
1225 
1226  for (const TileRawChannel* rawChannel : *rawChannelCollection) {
1227 
1228  HWIdentifier adcId = rawChannel->adc_HWID();
1229  HWIdentifier chId = m_tileHWID->channel_id(adcId);
1230  m_tileHWID->get_hash(chId, hash, &chan_context);
1231  if ( m_chanToSkip[hash] ) continue;
1232  int adc = m_tileHWID->adc(adcId);
1233  int channel = m_tileHWID->channel(adcId);
1234  int ch_type = 0;
1235  if (channel == chMBTS) {
1236  ch_type = 2;
1237  } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1238  || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1239  ch_type = 1;
1240  }
1241  if (emptyBad && !m_chanBad[hash] ) {
1242  m_chanBad[hash] = m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc).isBad() ||
1243  (DQstatus && !DQstatus->isAdcDQgood(ros,drawer,channel,adc)) ||
1244  (m_checkDCS && m_tileDCS->getDCSStatus(ros, drawer, channel) > TileDCSState::WARNING);
1245  }
1246 
1247  if (allowAmpCheck) {
1248 
1249  float amp = rawChannel->amplitude();
1250  float time = rawChannel->time();
1251  if (fillChanEne) {
1252  m_chanEne[hash] = amp;
1253  m_chanTime[hash] = time;
1254  m_chanQua[hash] = rawChannel->quality();
1255  } else {
1256  m_chanDsp[hash] = amp;
1257  m_chanTDsp[hash] = time;
1258  }
1259 
1260  if ( (m_skipMasked && m_chanBad[hash]) ||
1261  (m_skipMBTS && channel == chMBTS) ||
1262  (m_skipEmpty && TileDQstatus::isChEmpty(ros, drawer, channel) > 0) ||
1263  m_skipGain[adc] )
1264  continue;
1265 
1266  bool ampOk = false;
1267  if (amp < m_minEneChan[ch_type] ) {
1268  ampOk = m_bitEneChan[ch_type][0];
1269  } else if (amp > m_maxEneChan[ch_type] ) {
1270  ampOk = m_bitEneChan[ch_type][2];
1271  } else {
1272  ampOk = m_bitEneChan[ch_type][1];
1273  }
1274 
1275  bool timeOk = false;
1276  if (time < m_minTimeChan[ch_type] ) {
1277  timeOk = m_bitTimeChan[ch_type][0];
1278  } else if (time > m_maxTimeChan[ch_type] ) {
1279  timeOk = m_bitTimeChan[ch_type][2];
1280  } else {
1281  timeOk = m_bitTimeChan[ch_type][1];
1282  }
1283 
1284  if (ampOk && timeOk) {
1285 
1286  ATH_MSG_VERBOSE(evtnum.str()
1287  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(adcId)
1288  << " ch_ene = " << amp << " ch_t = " << time);
1289 
1290  m_chanSel[hash] = true;
1291 
1292  if (amp < chmin) {
1293  chmin = amp;
1294  minCh = rawChannel;
1295  } else if (amp > chmax) {
1296  chmax = amp;
1297  maxCh = rawChannel;
1298  }
1299 
1300  if (time<tcmin) {
1301  tcmin = time;
1302  tminCh = rawChannel;
1303  }
1304  else if (time>tcmax) {
1305  tcmax = time;
1306  tmaxCh = rawChannel;
1307  }
1308  }
1309  }
1310  }
1311  }
1312 
1313  for (index = hashNext - 48; index < hashNext; ++index) {
1314  if ((m_chanSel[index] && rawdata) || someDQerrors) {
1315  ATH_MSG_VERBOSE(evtnum.str()
1316  << " drw " << drwname(rawChannelCollection->identify())
1317  << " nBadMB = " << nbadMB
1318  << " nBadDMU = " << nbad
1319  << " EvtBCID = " << m_evtBCID
1320  << " DSPBCID = " << rawChannelCollection->getFragDSPBCID()
1321  << " GlobCRC = " << rawChannelCollection->getFragGlobalCRC() << " " << GlobalCRCErr
1322  << " error = 0x" << std::hex << error
1323  << " FE_CRC = 0x" << rawChannelCollection->getFragFEChipMask() << " 0x" << FE_DMUmask
1324  << " ROD_CRC = 0x" << rawChannelCollection->getFragRODChipMask() << " 0x" << ROD_DMUmask
1325  << " BCIDErr = 0x" << rawChannelCollection->getFragBCID() << " 0x" << BCIDErr
1326  << " MemPar = 0x" << rawChannelCollection->getFragMemoryPar()
1327  << " HeadForm = 0x"<< rawChannelCollection->getFragHeaderBit()
1328  << " HeadPar = 0x" << rawChannelCollection->getFragHeaderPar()
1329  << " SampForm = 0x"<< rawChannelCollection->getFragSampleBit()
1330  << " SampPar = 0x" << rawChannelCollection->getFragSamplePar()
1331  << std::dec);
1332  break;
1333  }
1334  }
1335  }
1336 
1337  if (nbadMBMax >= m_minBadMB) {
1338  ++m_dqerr;
1339  statusOk = true;
1340  ATH_MSG_DEBUG( nevtnum.str()
1341  << " drw " << drwname((collMBMax) ? collMBMax->identify() : 0)
1342  << " nBadMB = " << nbadMBMax
1343  << " accepted");
1344 
1345  } else if (nbadMax >= m_minBadDMU && nbadMax <= m_maxBadDMU) {
1346  ++m_dqerr;
1347  statusOk = true;
1348  ATH_MSG_DEBUG( nevtnum.str()
1349  << " drw " << drwname((collMax)?collMax->identify():0)
1350  << " nBadDMU = " << nbadMax
1351  << " accepted");
1352  }
1353 
1354  if (tminCh && tminCh != minCh && tminCh != maxCh) {
1355  ATH_MSG_DEBUG(nevtnum.str()
1356  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(tminCh->adc_HWID())
1357  << " ch_e = " << tminCh->amplitude()
1358  << " tmin =" << tminCh->time());
1359  }
1360 
1361  if (tmaxCh && tmaxCh != minCh && tmaxCh != maxCh) {
1362  ATH_MSG_DEBUG(nevtnum.str()
1363  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(tmaxCh->adc_HWID())
1364  << " ch_e = " << tmaxCh->amplitude()
1365  << " tmax = " << tmaxCh->time());
1366  }
1367 
1368  if (minCh) {
1369  if (!cellminCh) ++m_minChan;
1370  statusOk = true;
1371  const char * tit = (tminCh == minCh) ? " tmin = ": ((tmaxCh == minCh) ? " tmax = ": " t = ");
1372  ATH_MSG_DEBUG(nevtnum.str()
1373  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(minCh->adc_HWID())
1374  << " ch_emin = " << chmin
1375  << tit << minCh->time()
1376  << " accepted");
1377  }
1378  if (maxCh) {
1379  if (!cellmaxCh) ++m_maxChan;
1380  statusOk = true;
1381  const char * tit = (tminCh == maxCh) ? " tmin = ": ((tmaxCh == maxCh) ? " tmax = ": " t = ");
1382  ATH_MSG_DEBUG(nevtnum.str()
1383  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(maxCh->adc_HWID())
1384  << " ch_emax = " << chmax
1385  << tit << maxCh->time()
1386  << " accepted");
1387  }
1388  emptyBad = false;
1389  }
1390  }
1391 
1392 
1393  if (m_readDigits) {
1394 
1395  // Pointer to a Tile digits container
1396  SG::ReadHandle<TileDigitsContainer> digitsContainer(m_digitsContainerKey);
1397 
1398  if (!digitsContainer.isValid()) {
1399  ATH_MSG_WARNING("Unable to read TileDigitsContainer from EventStore, disable reading of this container");
1400  m_readDigits = false;
1401 
1402  } else {
1403 
1404  IdContext chan_context = m_tileHWID->channel_context();
1405  IdentifierHash hash;
1406  int index,pmt;
1407  int nConst = 0;
1408  int nJump = 0;
1409  int nDmuErr = 0;
1410  int nOverLG = 0;
1411  int nOverHG = 0;
1412  int nUnderLG = 0;
1413  int nUnderHG = 0;
1414 
1415  for (const TileDigitsCollection * digitsCollection : *digitsContainer) {
1416 
1417  int frag = digitsCollection->identify();
1418  bool eb = (frag > 0x2ff);
1419  bool ebsp = (frag == 0x30e || frag == 0x411);
1420 
1421  int ros = frag >> 8;
1422  int drawer = frag & 0x3F;
1423  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
1424  if ( m_drawerToSkip[drawerIdx] ) continue;
1425 
1426  int chMBTS = -1;
1427  if (eb) {
1428  for (int ch: {12,4,0}) {
1429  m_cabling->h2s_cell_id_index(ros,drawer,ch,index,pmt);
1430  if (index == -2) {
1431  chMBTS = ch;
1432  break;
1433  }
1434  }
1435  }
1436 
1437  int nChBadDB = 0;
1438  int nChBadNC = 0;
1439  int nChBad = 0;
1440  int nChTot = 0;
1441  int nChDmu[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1442  int nChBadDmu[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1443 
1444  for (const TileDigits* tile_digits : *digitsCollection) {
1445 
1446  ++nChTot;
1447 
1448  HWIdentifier adcId = tile_digits->adc_HWID();
1449  HWIdentifier chId = m_tileHWID->channel_id(adcId);
1450  m_tileHWID->get_hash(chId, hash, &chan_context);
1451  if ( m_chanToSkip[hash] ) continue;
1452  int channel = m_tileHWID->channel(adcId);
1453  int dmu = channel/3;
1454  ++nChDmu[dmu];
1455  int chEmpty = TileDQstatus::isChEmpty(ros, drawer, channel);
1456  bool isConnected = (chEmpty < 2);
1457  if (!isConnected) ++nChBadNC;
1458  int adc = m_tileHWID->adc(adcId);
1459  const char *cellname = "";
1460  int ch_type = 0;
1461  if (channel == chMBTS) {
1462  cellname = " MBTS";
1463  ch_type = 2;
1464  } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1465  || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1466  cellname = " GAP";
1467  ch_type = 1;
1468  } else if (chEmpty > 0) {
1469  cellname = " EMPTY";
1470  }
1471 
1472  const char *badname = "";
1473  if (DQstatus && !DQstatus->isAdcDQgood(ros,drawer,channel,adc)) {
1474  badname = " BADDQ";
1475  if (isConnected) {
1476  ++nChBad;
1477  ++nChBadDmu[dmu];
1478  }
1479  } else if (m_checkDCS && m_tileDCS->getDCSStatus(ros, drawer, channel) > TileDCSState::WARNING) {
1480  badname = " BADDCS";
1481  } else if (m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc).isBad()) {
1482  badname = " BADDB";
1483  if (isConnected) {
1484  ++nChBadDB;
1485  }
1486  } else if (m_chanBad[hash]) {
1487  if (badFromCell) {
1488  if (ch_type != 2) badname = " BADQUAL";
1489  m_chanQua[hash] = 999;
1490  if (isConnected && ch_type!=2) {
1491  ++nChBad;
1492  ++nChBadDmu[dmu];
1493  }
1494  } else {
1495  badname = " BADUNKN"; // should never see this
1496  }
1497  } else if (badFromCell && m_chanEne[hash] == 0.0) {
1498  badname = " BADDIGI"; // temporary fix, (for May-2012 ESD), should never get this
1499  if (isConnected) {
1500  ++nChBad;
1501  ++nChBadDmu[dmu];
1502  }
1503  }
1504  const char *enename = " ene = ";
1505  const char *timename = " time = ";
1506  const char *qualname = " qual = ";
1507  if (badFromCell && badname[0] != 0) {
1508  enename = " BAD = ";
1509  if (m_chanDsp.size()) {
1510  qualname = " eDSP = ";
1511  m_chanQua[hash] = m_chanDsp[hash];
1512  }
1513  if (m_chanTDsp.size()) {
1514  timename = " tDSP = ";
1515  m_chanTime[hash] = m_chanTDsp[hash];
1516  }
1517  }
1518 
1519  char badnm[30];
1520  sprintf(badnm," BADDIGIEX%s",badname);
1521  float dmin,dmax;
1522 
1523  std::vector<float> samples = tile_digits->samples();
1524  int nSamp = samples.size();
1525  if (nSamp > 6) {
1526 
1527  bool useCh= !( (m_skipMBTS && channel == chMBTS) ||
1528  (m_skipEmpty && chEmpty > 0) );
1529  bool checkCh = !( (m_skipMasked && m_chanBad[hash]) ) && useCh && m_checkJumps;
1530 
1531  int err = TileRawChannelBuilder::CorruptedData(ros,drawer,channel,adc,samples,dmin,dmax,m_ADCmaxMinusEps,m_ADCmaskValueMinusEps);
1532 
1533  if (badname[0]==0) {
1534  if (err && err>-3) { // do not consider all zeros in empty samples as error
1535  if (isConnected || err != -2) {
1536  if (checkCh) m_chanSel[hash] = true;
1537  badname = badnm;
1538  ++nChBad;
1539  ++nChBadDmu[dmu];
1540  if (!isConnected) --nChBadNC;
1541  }
1542  if (err > 0) {
1543  if (err < 10) {
1544  badnm[9] = 48+err;
1545  } else if (err < 36) {
1546  badnm[9] = 55+err;
1547  }
1548  } else {
1549  badnm[9] = 48;
1550  }
1551  } else {
1552  // old error types, used for tests in August 2012
1553  // expect to see only warningE7 and warningE8 for gap/crack
1554  int warn = Are3FF(samples, adc, ch_type);
1555  if (warn) {
1556  if (checkCh) m_chanSel[hash] = true;
1557  sprintf(badnm," warningE%d%s",warn,badname);
1558  badname = badnm;
1559  }
1560  }
1561  }
1562 
1563  if ((!err) // channel without bad patterns
1564  && (useCh) // normal connected channel
1565  && (badname[0] == 0 || badname[1] == 'w' // no digital error
1566  || (badname[4] == 'Q' && !m_skipMasked))) { // error from TileCell but it is ignored
1567 
1568  if (adc) { // HG
1569 
1570  if (dmax > m_overflowHG) {
1571  m_chanSel[hash] = true; // always print overflows
1572  if (m_checkOverHG){
1573  ++nOverHG;
1574  }
1575  }
1576  if (dmin < m_underflowHG) {
1577  m_chanSel[hash] = true; // always print underflows
1578  if (m_checkUnderHG){
1579  ++nUnderHG;
1580  }
1581  }
1582 
1583  } else { // LG
1584 
1585  if (dmax > m_overflowLG) {
1586  m_chanSel[hash] = true; // always print overflows
1587  if (m_checkOverLG){
1588  ++nOverLG;
1589  }
1590  }
1591  if (dmin < m_underflowLG) {
1592  m_chanSel[hash] = true; // always print underflows
1593  if (m_checkUnderLG){
1594  ++nUnderLG;
1595  }
1596  }
1597  }
1598  }
1599 
1600  bool someSampErrors = false;
1601 
1602  if (m_checkJumps && (checkCh || m_chanSel[hash])) {
1603 
1604  float pedDelta = (adc ? m_pedDeltaHG : m_pedDeltaLG);
1605  float jumpDelta = (adc ? m_jumpDeltaHG : m_jumpDeltaLG);
1606 
1607  float ped = samples[0];
1608  float dmin = ped;
1609  float dmax = ped;
1610  int nped = 1;
1611  int npedmax = 1;
1612  bool cnstPed = true;
1613  bool cnstPedmax = true;
1614  for (int i = 1; i < nSamp; ++i) {
1615  float smp = samples[i];
1616  float dped = smp - ped;
1617  if (fabs(dped) < pedDelta) {
1618  ++nped;
1619  if (dped != 0.0) {
1620  cnstPed = false;
1621  ped += dped/nped;
1622  }
1623  } else {
1624  if (nped>npedmax) {
1625  npedmax=nped;
1626  cnstPedmax = cnstPed;
1627  }
1628  cnstPed = true;
1629  ped = smp;
1630  nped = 1;
1631  }
1632  if (smp<dmin) {
1633  dmin = smp;
1634  } else if (smp>dmax) {
1635  dmax = smp;
1636  }
1637  }
1638  if (nped>npedmax) {
1639  npedmax=nped;
1640  cnstPedmax = cnstPed;
1641  }
1642 
1643  if (dmax - dmin >= jumpDelta) {
1644  bool accEmin = (m_chanEne[hash]<m_minEneChan[ch_type]);
1645  bool accEmax = (m_chanEne[hash]>m_maxEneChan[ch_type]);
1646  bool accCnst = false;
1647  bool accJump = false;
1648  bool cnstMin = true;
1649  bool cnstMax = true;
1650  bool jumpNeg = false;
1651  bool jumpPos = false;
1652  bool jumpEnd = false;
1653  bool jumpZer = false;
1654  bool jumpOve = false;
1655  bool narrowUp = false;
1656  bool narrowDown = false;
1657  if (npedmax >= m_constLength && ((dmax-ped) >= jumpDelta || (ped-dmin) >= jumpDelta) ) {
1658  ++nConst;
1659  accCnst = true;
1660  }
1661  int nmin = 0;
1662  int nmax = 0;
1663  int pmin = -1;
1664  int pmax = -1;
1665  float abovemin = dmax;
1666  float belowmax = dmin;
1667  for (int i = 0; i < nSamp; ++i) {
1668  float smp = samples[i];
1669  if (smp - dmin < pedDelta) {
1670  ++nmin;
1671  pmin = i;
1672  if (smp != dmin) cnstMin = false;
1673  }
1674  if (dmax - smp < pedDelta) {
1675  ++nmax;
1676  pmax = i;
1677  if (smp != dmax) cnstMax = false;
1678  }
1679  if (smp < abovemin && smp > dmin) {
1680  abovemin = smp;
1681  }
1682  if (smp > belowmax && smp < dmax) {
1683  belowmax = smp;
1684  }
1685  }
1686  if (nmax + nmin == nSamp) {
1687  if (nmax > 1 && nmin > 1) {
1688  ++nJump;
1689  accJump = true;
1690  } else if (nmax == 1) {
1691  if (pmax < nSamp - 1) { // ignore jump in last sample
1692  ++nJump;
1693  accJump = true;
1694  jumpPos = true;
1695  cnstMax = false;
1696  }
1697  if (pmax == 0 || pmax == nSamp - 1) {
1698  jumpEnd = true;
1699  }
1700  } else if (nmin == 1) {
1701  ++nJump;
1702  accJump = true;
1703  jumpNeg = true;
1704  cnstMin = false;
1705  if (pmin == 0 || pmin == nSamp - 1) {
1706  jumpEnd = true;
1707  }
1708  }
1709  }
1710  if (dmin == 0.0) {
1711  if (!accJump) {
1712  ++nJump;
1713  accJump = true;
1714  cnstMin = false;
1715  cnstMax = false;
1716  }
1717  jumpZer = true;
1718  }
1719  if (dmax > m_ADCmaxMinusEps) {
1720  if (!accJump) {
1721  ++nJump;
1722  accJump = true;
1723  cnstMin = false;
1724  cnstMax = false;
1725  }
1726  jumpOve = true;
1727  }
1728  float secondMax = (dmax-dmin)*m_secondMaxLevel;
1729  if (pmax > 0 && pmax < nSamp-1 && std::max(samples[pmax-1], samples[pmax+1]) < dmin+secondMax) {
1730  if (!accJump) {
1731  ++nJump;
1732  accJump = true;
1733  cnstMax = false;
1734  if (nmin + nmax != nSamp) {
1735  cnstMin = false;
1736  }
1737  }
1738  narrowUp = true;
1739  }
1740  if (pmin > 0 && pmin < nSamp - 1 && std::min(samples[pmin - 1], samples[pmin + 1]) > dmax - secondMax) {
1741  if (!accJump) {
1742  ++nJump;
1743  accJump = true;
1744  cnstMin = false;
1745  if (nmin + nmax != nSamp) {
1746  cnstMax = false;
1747  }
1748  }
1749  narrowDown = true;
1750  }
1751 
1752  if (accEmin || accEmax || accCnst || accJump) {
1753  someSampErrors = true;
1754  ATH_MSG_VERBOSE (evtnum.str()
1755  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(adcId)
1756  << enename << m_chanEne[hash] << " samp = " << samples[0]
1757  << " " << samples[1] << " " << samples[2] << " " << samples[3]
1758  << " " << samples[4] << " " << samples[5] << " " << samples[6]
1759  << timename << m_chanTime[hash]
1760  << qualname << m_chanQua[hash]
1761  << cellname << badname
1762  << ((accEmin) ? " neg_e" : "")
1763  << ((accEmax) ? " pos_e" : "")
1764  << ((accCnst) ? " const" : "")
1765  << ((accCnst&&cnstPedmax) ? "Const" : "")
1766  << ((accJump) ? " jump" : "")
1767  << ((accJump&&jumpZer) ? "Zero" : "")
1768  << ((accJump&&jumpOve) ? "Over" : "")
1769  << ((accJump&&jumpPos) ? "SingleUp" : ((narrowUp) ? "NarrowUp" : "") )
1770  << ((accJump&&jumpNeg) ? "SingleDown" : ((narrowDown) ? "NarrowDown" : "") )
1771  << ((accJump&&jumpEnd) ? "AtEdge" : "")
1772  << ((accJump&&cnstMin) ? "ConstMin" : "")
1773  << ((accJump&&cnstMax) ? "ConstMax" : "")
1774  << " " << dmax-dmin);
1775  }
1776  }
1777  }
1778 
1779  if (someSampErrors) {
1780  m_chanSel[hash] = true;
1781  } else if (m_chanSel[hash]) {
1782  bool accEmin = (m_chanEne[hash] < m_minEneChan[ch_type]);
1783  bool accEmax = (m_chanEne[hash] > m_maxEneChan[ch_type]);
1784  bool jumpOve = (dmax>m_ADCmaxMinusEps);
1785  bool jumpZer = (dmin < 0.01);
1786  ATH_MSG_VERBOSE(evtnum.str()
1787  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(adcId)
1788  << enename << m_chanEne[hash] << " samp = " << samples[0]
1789  << " " << samples[1] << " " << samples[2] << " " << samples[3]
1790  << " " << samples[4] << " " << samples[5] << " " << samples[6]
1791  << timename << m_chanTime[hash]
1792  << qualname << m_chanQua[hash]
1793  << cellname << badname
1794  << ((accEmin) ? " neg_e" : "")
1795  << ((accEmax) ? " pos_e" : "")
1796  <<((jumpZer) ? " underflow" : "")
1797  <<((jumpOve) ? " overflow" : "") );
1798  }
1799 
1800  }
1801  }
1802  if (m_checkDMUs && nChBad > 1 && nChBad + nChBadDB + nChBadNC < nChTot) {
1803  int nChBad1 = 0;
1804  int nChBad2 = 0;
1805  int nDmuBad1 = 0;
1806  int nDmuBad2 = 0;
1807  int nDmuBad = 0;
1808  int nDmuTot = 0;
1809  bool has23 = false;
1810  for (int dmu = 0; dmu < 16; ++dmu) {
1811  if (nChDmu[dmu] > 0) {
1812  ++nDmuTot;
1813  if (nChBadDmu[dmu] > 0) {
1814  ++nDmuBad;
1815  if (dmu < 8) {
1816  nChBad1 += nChBadDmu[dmu];
1817  ++nDmuBad1;
1818  } else {
1819  nChBad2 += nChBadDmu[dmu];
1820  ++nDmuBad2;
1821  }
1822  if (nChBadDmu[dmu] == 2 && nChDmu[dmu] == 3) has23 = true;
1823  }
1824  }
1825  }
1826  if (nDmuBad == 1 /* && (!has23) */ ) continue;
1827  if (nDmuBad == 2 && nChBad < 3) continue;
1828 
1829  if (nDmuBad>2 || nChBad > 9 || nChTot > 19 || has23) {
1830 
1831  ++nDmuErr;
1832 
1833  for (const TileDigits* tile_digits : *digitsCollection) {
1834 
1835  HWIdentifier adcId = tile_digits->adc_HWID();
1836  HWIdentifier chId = m_tileHWID->channel_id(adcId);
1837  m_tileHWID->get_hash(chId, hash, &chan_context);
1838  if ( m_chanToSkip[hash] ) continue;
1839  std::vector<float> samples = tile_digits->samples();
1840 
1841  if (!m_chanSel[hash] && samples.size()>6) {
1842  int channel = m_tileHWID->channel(adcId);
1843  int adc = m_tileHWID->adc(adcId);
1844  int chEmpty = TileDQstatus::isChEmpty(ros, drawer, channel);
1845  const char *cellname = "";
1846  int ch_type = 0;
1847  if (channel == chMBTS) {
1848  cellname = " MBTS";
1849  ch_type = 2;
1850  } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1851  || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1852  cellname = " GAP";
1853  ch_type = 1;
1854  } else if (chEmpty > 0) {
1855  cellname = " EMPTY";
1856  }
1857  const char *badname = "";
1858  if (m_tileBadChanTool->getAdcStatus(drawerIdx, channel, adc).isBad()) {
1859  badname = " BADDB";
1860  } else if (DQstatus && !DQstatus->isAdcDQgood(ros, drawer, channel, adc)) {
1861  badname = " BADDQ";
1862  } else if (m_checkDCS && m_tileDCS->getDCSStatus(ros, drawer, channel) > TileDCSState::WARNING) {
1863  badname = " BADDCS";
1864  } else if (m_chanBad[hash]) {
1865  if (badFromCell) {
1866  if (ch_type != 2) badname = " BADQUAL";
1867  m_chanQua[hash] = 999;
1868  } else {
1869  badname = " BADUNKN"; // should never see this
1870  }
1871  } else if (badFromCell && m_chanEne[hash] == 0.0) {
1872  badname = " BADDIGI"; // temporary fix, (for May-2012 ESD), should never get this
1873  }
1874 
1875  char badnm[30];
1876  sprintf(badnm, " BADDIGIEX%s", badname);
1877  float dmin, dmax;
1878 
1879  int err = TileRawChannelBuilder::CorruptedData(ros, drawer,
1880  channel, adc, samples, dmin, dmax, m_ADCmaxMinusEps,m_ADCmaskValueMinusEps);
1881  if (err) {
1882  bool isConnected = (chEmpty < 2);
1883  if (isConnected || err != -2) {
1884  badname = badnm;
1885  }
1886  if (err > 0) {
1887  if (err < 10) {
1888  badnm[9] = 48 + err;
1889  } else if (err < 36) {
1890  badnm[9] = 55 + err;
1891  }
1892  } else {
1893  badnm[9] = 48;
1894  }
1895  }
1896 
1897  const char *enename = " ene = ";
1898  const char *timename = " time = ";
1899  const char *qualname = " qual = ";
1900  if (badFromCell && badname[0] != 0) {
1901  enename = " BAD = ";
1902  if (m_chanDsp.size()) {
1903  qualname = " eDSP = ";
1904  m_chanQua[hash] = m_chanDsp[hash];
1905  }
1906  if (m_chanTDsp.size()) {
1907  timename = " tDSP = ";
1908  m_chanTime[hash] = m_chanTDsp[hash];
1909  }
1910  }
1911 
1912  bool accEmin = (m_chanEne[hash]<m_minEneChan[ch_type]);
1913  bool accEmax = (m_chanEne[hash]>m_maxEneChan[ch_type]);
1914  bool jumpOve = (dmax > m_ADCmaxMinusEps);
1915  bool jumpZer = (dmin < 0.01);
1916 
1917  ATH_MSG_VERBOSE(evtnum.str()
1918  << " chan " << std::left << std::setw(14) << m_tileHWID->to_string(adcId)
1919  << enename << m_chanEne[hash] << " samp = " << samples[0]
1920  << " " << samples[1] << " " << samples[2] << " " << samples[3]
1921  << " " << samples[4] << " " << samples[5] << " " << samples[6]
1922  << timename << m_chanTime[hash]
1923  << qualname << m_chanQua[hash]
1924  << cellname << badname
1925  << ((accEmin) ? " neg_e" : "")
1926  << ((accEmax) ? " pos_e" : "")
1927  << ((jumpZer) ? " underflow" : "")
1928  << ((jumpOve) ? " overflow" : "") );
1929 
1930  }
1931  }
1932  }
1933 
1934  std::ostringstream badstr;
1935  badstr << " ch: " << nChBad1 << " + " << nChBad2 << " = " << nChBad << " / " << nChTot << " = " << 100*nChBad/nChTot
1936  << " % dmu: " << nDmuBad1 << " + " << nDmuBad2 << " = " << nDmuBad << " / " << nDmuTot << " ";
1937  for (int dmu=0; dmu<16; ++dmu) {
1938  if (nChDmu[dmu]>0) {
1939  badstr << " " << std::hex << dmu << "=" << nChBadDmu[dmu] << "/" << nChDmu[dmu];
1940  }
1941  }
1942  ATH_MSG_VERBOSE (evtnum.str()
1943  << " drw " << drwname(digitsCollection->identify()) << badstr.str());
1944  }
1945  }
1946 
1947  if (nConst) {
1948  ++m_const;
1949  statusOk = true;
1950  ATH_MSG_DEBUG( nevtnum.str()
1951  << " n_const_sample_errors = " << nConst
1952  << " accepted");
1953  }
1954  if (nJump) {
1955  ++m_jump;
1956  statusOk = true;
1957  ATH_MSG_DEBUG( nevtnum.str()
1958  << " n_jump_sample_errors = " << nJump
1959  << " accepted");
1960  }
1961  if (nOverLG) {
1962  ++m_overLG;
1963  statusOk = true;
1964  ATH_MSG_DEBUG( nevtnum.str()
1965  << " n_overflow_LG = " << nOverLG
1966  << " accepted");
1967  }
1968  if (nOverHG) {
1969  ++m_overHG;
1970  statusOk = true;
1971  ATH_MSG_DEBUG(nevtnum.str()
1972  << " n_overflow_HG = " << nOverHG
1973  << " accepted");
1974  }
1975  if (nUnderLG) {
1976  ++m_underLG;
1977  statusOk = true;
1978  ATH_MSG_DEBUG( nevtnum.str()
1979  << " n_underflow_LG = " << nUnderLG
1980  << " accepted");
1981  }
1982  if (nUnderHG) {
1983  ++m_underHG;
1984  statusOk = true;
1985  ATH_MSG_DEBUG(nevtnum.str()
1986  << " n_underflow_HG = " << nUnderHG
1987  << " accepted");
1988  }
1989  if (nDmuErr) {
1990  ++m_dmuerr;
1991  statusOk = true;
1992  ATH_MSG_DEBUG( nevtnum.str()
1993  << " n_DMU_errors = " << nDmuErr
1994  << " accepted");
1995  }
1996  }
1997  }
1998 
1999  if (m_printOnly)
2000  this->setFilterPassed (false);
2001  else
2002  this->setFilterPassed (statusOk);
2003 
2004  if (statusOk) {
2005  ++m_accept;
2006  //ATH_MSG_VERBOSE (nevtnum.str() << " accepted");
2007  } else {
2008  //ATH_MSG_VERBOSE (nevtnum.str() << " rejected");
2009  }
2010 
2011  return StatusCode::SUCCESS;
2012 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode TileCellSelector::finalize ( )
overridevirtual

Definition at line 2092 of file TileCellSelector.cxx.

2092  {
2093  //ATH_MSG_DEBUG ("finalize()");
2094 
2095  ATH_MSG_INFO ("Processed " << m_counter << " events, accepted " << m_accept
2096  << " (" << m_minCell << "/" << m_minChan
2097  << "," << m_maxCell << "/" << m_maxChan
2098  << "," << m_jump << "/" << m_const
2099  << "," << m_overLG << "/" << m_overHG
2100  << "," << m_underLG << "/" << m_underHG
2101  << "," << m_dqerr << "/" << m_dmuerr
2102  << "," << m_warnerr << ") events.");
2103 
2104  //ATH_MSG_DEBUG ("finalize() successful");
2105 
2106  return StatusCode::SUCCESS;
2107 }

◆ initialize()

StatusCode TileCellSelector::initialize ( )
overridevirtual

Definition at line 152 of file TileCellSelector.cxx.

152  {
153  //ATH_MSG_DEBUG("in initialize()");
154 
155  ATH_CHECK( m_eventInfoKey.initialize() );
156 
157  ATH_CHECK(detStore()->retrieve(m_tileID, "TileID"));
158  ATH_CHECK(detStore()->retrieve(m_tileHWID, "TileHWID"));
159 
160  ATH_CHECK(detStore()->retrieve(m_tileInfo, m_infoName));
161  m_ADCmaxMinusEps = m_tileInfo->ADCmax() - 0.01;
162  m_ADCmaskValueMinusEps = m_tileInfo->ADCmaskValue() - 0.01; // indicates channels which were masked in background dataset
163 
164  m_cabling = TileCablingService::getInstance();
165 
166  ATH_CHECK(m_tileBadChanTool.retrieve());
167 
168  if (m_checkDCS) {
169  ATH_CHECK(m_tileDCS.retrieve());
170  } else {
171  m_tileDCS.disable();
172  }
173 
174  ATH_MSG_INFO( "Cell container "
175  << ((m_cellContainerKey.key().empty()) ? "NOT SET" : m_cellContainerKey.key()) );
176  ATH_MSG_INFO( "Digits container "
177  << ((m_digitsContainerKey.key().empty()) ? "NOT SET" : m_digitsContainerKey.key()));
178  ATH_MSG_INFO( "RawChannel container "
179  << ((m_rawChannelContainerKey.key().empty()) ? "NOT SET" : m_rawChannelContainerKey.key()));
180 
181  ATH_MSG_INFO( "CheckJumps " << ((m_checkJumps) ? "true" : "false"));
182  ATH_MSG_INFO( "CheckDMUs " << ((m_checkDMUs) ? "true" : "false"));
183  ATH_MSG_INFO( "CheckOverLG " << ((m_checkOverLG) ? "true" : "false"));
184  ATH_MSG_INFO( "CheckOverHG " << ((m_checkOverHG) ? "true" : "false"));
185  ATH_MSG_INFO( "CheckUnderLG " << ((m_checkUnderLG) ? "true" : "false"));
186  ATH_MSG_INFO( "CheckUnderHG " << ((m_checkUnderHG) ? "true" : "false"));
187 
188  if (m_overflowLG < 0) m_overflowLG += m_tileInfo->ADCmax();
189  if (m_overflowHG < 0) m_overflowHG += m_tileInfo->ADCmax();
190  ATH_MSG_INFO( "OverflowLG " << m_overflowLG);
191  ATH_MSG_INFO( "OverflowHG " << m_overflowHG);
192  ATH_MSG_INFO( "UnderflowLG " << m_underflowLG);
193  ATH_MSG_INFO( "UnderflowHG " << m_underflowHG);
194 
195  ATH_MSG_INFO( "SkipEmpty " << ((m_skipEmpty) ? "true" : "false"));
196  ATH_MSG_INFO( "SkipMasked " << ((m_skipMasked) ? "true" : "false"));
197  ATH_MSG_INFO( "SkipMBTS " << ((m_skipMBTS) ? "true" : "false"));
198  ATH_MSG_INFO( "CheckDCS " << ((m_checkDCS) ? "true" : "false"));
199 
200 
201  m_readCells = !m_cellContainerKey.key().empty();
202  m_readRawChannels = !m_rawChannelContainerKey.key().empty();
203  m_readDigits = !m_digitsContainerKey.key().empty();
204 
205  if (m_readCells) {
206  ATH_MSG_INFO( "MinEnergyCell < " << m_minEneCell);
207  ATH_MSG_INFO( "MaxEnergyCell > " << m_maxEneCell);
208  ATH_MSG_INFO( "PtnEnergyCell = " << m_ptnEneCell);
209  ATH_MSG_INFO( "MinTimeCell < " << m_minTimeCell);
210  ATH_MSG_INFO( "MaxTimeCell > " << m_maxTimeCell);
211  ATH_MSG_INFO( "PtnTimeCell = " << m_ptnTimeCell);
212 
213  ATH_CHECK( m_cellContainerKey.initialize() );
214  }
215 
216  if (m_readCells || m_readRawChannels) {
217  ATH_MSG_INFO( "MinEnergyChan < " << m_minEneChan[0]);
218  ATH_MSG_INFO( "MaxEnergyChan > " << m_maxEneChan[0]);
219  ATH_MSG_INFO( "PtnEnergyChan = " << m_ptnEneChan[0]);
220  ATH_MSG_INFO( "MinEnergyGap < " << m_minEneChan[1]);
221  ATH_MSG_INFO( "MaxEnergyGap > " << m_maxEneChan[1]);
222  ATH_MSG_INFO( "PtnEnergyGap = " << m_ptnEneChan[1]);
223  ATH_MSG_INFO( "MinTimeChan < " << m_minTimeChan[0]);
224  ATH_MSG_INFO( "MaxTimeChan > " << m_maxTimeChan[0]);
225  ATH_MSG_INFO( "PtnTimeChan = " << m_ptnTimeChan[0]);
226  ATH_MSG_INFO( "MinTimeGap < " << m_minTimeChan[1]);
227  ATH_MSG_INFO( "MaxTimeGap > " << m_maxTimeChan[1]);
228  ATH_MSG_INFO( "PtnTimeGap = " << m_ptnTimeChan[1]);
229  }
230 
231  if (m_readRawChannels) {
232  ATH_MSG_INFO( "MinEnergyMBTS < " << m_minEneChan[2]);
233  ATH_MSG_INFO( "MaxEnergyMBTS > " << m_maxEneChan[2]);
234  ATH_MSG_INFO( "PtnEnergyMBTS = " << m_ptnEneChan[2]);
235  ATH_MSG_INFO( "MinTimeMBTS < " << m_minTimeChan[2]);
236  ATH_MSG_INFO( "MaxTimeMBTS > " << m_maxTimeChan[2]);
237  ATH_MSG_INFO( "PtnTimeMBTS = " << m_ptnTimeChan[2]);
238 
239  ATH_CHECK( m_rawChannelContainerKey.initialize() );
240  }
241 
242  switch (m_selectGain) {
243  case 0:
244  ATH_MSG_INFO( "Select Low gain channels only");
245  m_skipGain[TileID::LOWGAIN] = false;
246  m_skipGain[TileID::HIGHGAIN] = true;
247  break;
248  case 1:
249  ATH_MSG_INFO( "Select High gain channels only");
250  m_skipGain[TileID::LOWGAIN] = true;
251  m_skipGain[TileID::HIGHGAIN] = false;
252  break;
253  default:
254  ATH_MSG_INFO( "Select both gains");
255  break;
256  }
257 
258  if (!m_digitsContainerKey.key().empty()) {
259  if (m_checkJumps) {
260  ATH_MSG_INFO( "JumpDeltaHG " << m_jumpDeltaHG);
261  ATH_MSG_INFO( "JumpDeltaLG " << m_jumpDeltaLG);
262  ATH_MSG_INFO( "PedDetlaHG " << m_pedDeltaHG);
263  ATH_MSG_INFO( "PedDetlaLG " << m_pedDeltaLG);
264  ATH_MSG_INFO( "ConstLength " << m_constLength);
265  }
266 
267  ATH_CHECK( m_digitsContainerKey.initialize() );
268 
269  }
270 
271  if (!m_rawChannelContainerKey.key().empty()) {
272  if (m_checkDMUs) {
273  ATH_MSG_INFO( "MinBadDMU " << m_minBadDMU);
274  ATH_MSG_INFO( "MaxBadDMU " << m_maxBadDMU);
275  ATH_MSG_INFO( "MinBadMB " << m_minBadMB);
276  } else {
277  m_minBadDMU = 99;
278  m_maxBadDMU = -1;
279  m_minBadMB = 99;
280  }
281  ATH_MSG_INFO( "MaxVerboseCnt " << m_maxVerboseCnt);
282  }
283 
284  ATH_MSG_INFO( "CheckWarning " << ((m_checkWarning)? "true" : "false"));
285  ATH_MSG_INFO( "CheckError " << ((m_checkError) ? "true" : "false"));
286  ATH_MSG_INFO( "PrintOnly " << ((m_printOnly) ? "true" : "false"));
287 
288  if (m_drawer.size()>0) {
289  msg(MSG::INFO) << "Drawers which will be always printed:" << MSG::hex;
290  for (int frag: m_drawer) msg(MSG::INFO) << " 0x" << frag;
291  msg(MSG::INFO) << MSG::dec << endmsg;
292  }
293 
294  if (m_drawerToCheck.size()>0) {
295  msg(MSG::INFO) << "Only those drawers will be checked:" << MSG::hex;
296  for (int frag: m_drawerToCheck) msg(MSG::INFO) << " 0x" << frag;
297  msg(MSG::INFO) << MSG::dec << endmsg;
298  }
299 
300  if (m_chanToCheck.size()>0) {
301  msg(MSG::INFO) << "Only those channels will be checked:";
302  for (int ch: m_chanToCheck) msg(MSG::INFO) << " " << ch;
303  msg(MSG::INFO) << endmsg;
304  }
305 
306  m_nDrawerOff.resize(TileCalibUtils::getDrawerIdx(4, 63) + 1);
307 
308  //ATH_MSG_DEBUG ("initialize() successful");
309 
310  // convert patterns fo bolean arrays
311 
312  int digit=1;
313  int scale=10;
314  for (int i=0; i<ptnlength; ++i) {
315 
316  int bit=(m_ptnEneCell/digit)%scale;
317  m_bitEneCell[i] = (bit!=0);
318 
319  bit=(m_ptnTimeCell/digit)%scale;
320  m_bitTimeCell[i] = (bit!=0);
321 
322  for (int j=0; j<3; ++j) {
323 
324  int bit=(m_ptnEneChan[j]/digit)%scale;
325  m_bitEneChan[j][i] = (bit!=0);
326 
327  bit=(m_ptnTimeChan[j]/digit)%scale;
328  m_bitTimeChan[j][i] = (bit!=0);
329  }
330 
331  digit *= scale;
332  }
333 
334  m_chanToSkip.clear();
335  m_drawerToSkip.clear();
336  if (m_drawerToCheck.size()>0 || m_chanToCheck.size()>0 ) {
337  if (m_drawerToCheck.size()==0) {
338  m_drawerToCheck.resize(256);
339  auto itr = m_drawerToCheck.begin();
340  for (int frag : {0x100,0x200,0x300,0x400}) {
341  auto itr1 = itr+64;
342  std::iota(itr, itr1, frag);
343  itr = itr1;
344  }
345  } else if (m_chanToCheck.size()==0) {
346  m_chanToCheck.resize(48);
347  std::iota(m_chanToCheck.begin(), m_chanToCheck.end(), 0);
348  }
349  m_chanToSkip.resize(1+TileHWID::NOT_VALID_HASH,true);
350  m_drawerToSkip.resize(1+TileCalibUtils::getDrawerIdx(4,63),true);
351  IdContext chan_context = m_tileHWID->channel_context();
352  IdentifierHash hash;
353  for (int frag : m_drawerToCheck) {
354  int ros = frag >> 8;
355  int drawer = frag & 0x3F;
356  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
357  m_drawerToSkip[drawerIdx] = false;
358  HWIdentifier ch_id = m_tileHWID->channel_id(ros,drawer,0);
359  m_tileHWID->get_hash(ch_id, hash, &chan_context);
360  for (int chan: m_chanToCheck)
361  m_chanToSkip[hash+chan] = false;
362  }
363  } else {
364  m_chanToSkip.resize(1+TileHWID::NOT_VALID_HASH,false);
365  m_chanToSkip[TileHWID::NOT_VALID_HASH] = true;
366  m_drawerToSkip.resize(1+TileCalibUtils::getDrawerIdx(4,63),false);
367  }
368 
369  ATH_CHECK( m_dqStatusKey.initialize() );
370 
371  return StatusCode::SUCCESS;
372 }

◆ inputHandles()

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

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

◆ printCell()

void TileCellSelector::printCell ( const TileCell *  cell)
private

Definition at line 2016 of file TileCellSelector.cxx.

2016  {
2017  if (tile_cell==0) return;
2018 
2019  // int drw = 0; // drawer number, range 0-63, the same for both channels
2020  // int ch1 = -1, ch2 = -1; // channel number, range 0-47 or -1 for unknown
2021  int ros1 = 0, ros2 = 0;
2022 
2023  const CaloDetDescrElement * caloDDE = tile_cell->caloDDE();
2024  //Identifier id = tile_cell->ID();
2025 
2026  IdentifierHash hash1 = caloDDE->onl1();
2027  if (hash1 != TileHWID::NOT_VALID_HASH) {
2028  HWIdentifier hw1 = m_tileHWID->channel_id(hash1);
2029  //ch1 = m_tileHWID->channel(hw1);
2030  //drw = m_tileHWID->drawer(hw1);
2031  ros1 = m_tileHWID->ros(hw1);
2032  }
2033 
2034  IdentifierHash hash2 = caloDDE->onl2();
2035  if (hash2 != TileHWID::NOT_VALID_HASH) {
2036  HWIdentifier hw2 = m_tileHWID->channel_id(hash2);
2037  //ch2 = m_tileHWID->channel(hw2);
2038  //drw = m_tileHWID->drawer(hw2);
2039  ros2 = m_tileHWID->ros(hw2);
2040  if (ros1 == 0) ros1=ros2;
2041  } else {
2042  ros2 = ros1;
2043  }
2044 
2045  // something is wrong
2046  if (ros1 == 0) return;
2047  /*
2048  int module = m_tileID->module(id);
2049 
2050  int samp = m_tileID->sample(id);
2051 
2052  bool single_PMT_scin = (samp == TileID::SAMP_E);
2053  bool single_PMT_C10 = (m_tileID->section(id) == TileID::GAPDET &&
2054  samp == TileID::SAMP_C &&
2055  (! m_cabling->C10_connected(m_tileID->module(id))) );
2056 
2057  // distinguish cells with one or two PMTs
2058  bool single_PMT = single_PMT_C10 || single_PMT_scin;
2059 
2060  // distinguish normal cells and fantoms (e.g. non-existing D4 in EBA15, EBC18
2061  // or non-existing E3/E4 - they might appear in CaloCellContainer)
2062  bool real_cell = single_PMT_C10 || m_cabling->TileGap_connected(id);
2063 
2064  // note that in single PMT cell both badch1() and badch2() are changed together
2065  bool badch1 = (tile_cell->badch1());
2066  bool badch2 = (tile_cell->badch2());
2067 
2068  // 0 = both PMTs are good; 1= 1 PMT is bad; 2= both PMTs are bad, or PMT is bad for single PMT cell
2069  int cell_isbad = (int)badch1 + (int)badch2;
2070 
2071  int gn1 = tile_cell->gain1(); // gain of first PMT
2072  int gn2 = tile_cell->gain2(); // gain of second PMT
2073 
2074  bool ch1Ok = (ch1>-1 && gn1 != CaloGain::INVALIDGAIN);
2075  bool ch2Ok = (ch2>-1 && gn2 != CaloGain::INVALIDGAIN);
2076 
2077  // get the cell energy, time and position info
2078  double energy = tile_cell->energy();
2079  double time = tile_cell->time();
2080  double eta = tile_cell->eta();
2081  double phi = tile_cell->phi();
2082  double ene1 = tile_cell->ene1();
2083  double ene2 = tile_cell->ene2();
2084  double ediff = (single_PMT) ? 0.0 : tile_cell->eneDiff();
2085  double eratio = (energy!=0.0) ? ediff/energy : 0.0;
2086  double t1 = tile_cell->time1();
2087  double t2 = tile_cell->time2();
2088  double tdiff = (single_PMT) ? 0.0 : tile_cell->timeDiff();
2089  */
2090 }

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_accept

unsigned int TileCellSelector::m_accept
private

Definition at line 55 of file TileCellSelector.h.

◆ m_ADCmaskValueMinusEps

float TileCellSelector::m_ADCmaskValueMinusEps = 0.0F
private

Definition at line 180 of file TileCellSelector.h.

◆ m_ADCmaxMinusEps

float TileCellSelector::m_ADCmaxMinusEps = 0.0F
private

Definition at line 179 of file TileCellSelector.h.

◆ m_bitEneCell

bool TileCellSelector::m_bitEneCell[ptnlength] {}
private

Definition at line 139 of file TileCellSelector.h.

◆ m_bitEneChan

bool TileCellSelector::m_bitEneChan[3][ptnlength] {}
private

Definition at line 141 of file TileCellSelector.h.

◆ m_bitTimeCell

bool TileCellSelector::m_bitTimeCell[ptnlength] {}
private

Definition at line 140 of file TileCellSelector.h.

◆ m_bitTimeChan

bool TileCellSelector::m_bitTimeChan[3][ptnlength] {}
private

Definition at line 142 of file TileCellSelector.h.

◆ m_cabling

const TileCablingService* TileCellSelector::m_cabling
private

Definition at line 72 of file TileCellSelector.h.

◆ m_cellContainerKey

SG::ReadHandleKey<CaloCellContainer> TileCellSelector::m_cellContainerKey
private
Initial value:
{this,"CellContainerName",
"AllCalo", "Input Calo cell container key"}

Definition at line 111 of file TileCellSelector.h.

◆ m_chanBad

std::vector<bool> TileCellSelector::m_chanBad
private

Definition at line 97 of file TileCellSelector.h.

◆ m_chanDsp

std::vector<float> TileCellSelector::m_chanDsp
private

Definition at line 100 of file TileCellSelector.h.

◆ m_chanEne

std::vector<float> TileCellSelector::m_chanEne
private

Definition at line 98 of file TileCellSelector.h.

◆ m_chanQua

std::vector<float> TileCellSelector::m_chanQua
private

Definition at line 102 of file TileCellSelector.h.

◆ m_chanSel

std::vector<bool> TileCellSelector::m_chanSel
private

Definition at line 103 of file TileCellSelector.h.

◆ m_chanTDsp

std::vector<float> TileCellSelector::m_chanTDsp
private

Definition at line 101 of file TileCellSelector.h.

◆ m_chanTime

std::vector<float> TileCellSelector::m_chanTime
private

Definition at line 99 of file TileCellSelector.h.

◆ m_chanToCheck

std::vector<int> TileCellSelector::m_chanToCheck
private

Definition at line 172 of file TileCellSelector.h.

◆ m_chanToSkip

std::vector<bool> TileCellSelector::m_chanToSkip
private

Definition at line 104 of file TileCellSelector.h.

◆ m_checkDCS

bool TileCellSelector::m_checkDCS
private

Definition at line 155 of file TileCellSelector.h.

◆ m_checkDMUs

bool TileCellSelector::m_checkDMUs
private

Definition at line 157 of file TileCellSelector.h.

◆ m_checkError

bool TileCellSelector::m_checkError
private

Definition at line 167 of file TileCellSelector.h.

◆ m_checkJumps

bool TileCellSelector::m_checkJumps
private

Definition at line 156 of file TileCellSelector.h.

◆ m_checkOverHG

bool TileCellSelector::m_checkOverHG
private

Definition at line 159 of file TileCellSelector.h.

◆ m_checkOverLG

bool TileCellSelector::m_checkOverLG
private

Definition at line 158 of file TileCellSelector.h.

◆ m_checkUnderHG

bool TileCellSelector::m_checkUnderHG
private

Definition at line 161 of file TileCellSelector.h.

◆ m_checkUnderLG

bool TileCellSelector::m_checkUnderLG
private

Definition at line 160 of file TileCellSelector.h.

◆ m_checkWarning

bool TileCellSelector::m_checkWarning
private

Definition at line 166 of file TileCellSelector.h.

◆ m_const

unsigned int TileCellSelector::m_const
private

Definition at line 61 of file TileCellSelector.h.

◆ m_constLength

int TileCellSelector::m_constLength
private

Definition at line 148 of file TileCellSelector.h.

◆ m_counter

unsigned int TileCellSelector::m_counter
private

Definition at line 54 of file TileCellSelector.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileCellSelector::m_digitsContainerKey
private
Initial value:
{this,"DigitsContainerName",
"TileDigitsFlt", "Input Tile digits container key"}

Definition at line 114 of file TileCellSelector.h.

◆ m_dmuerr

unsigned int TileCellSelector::m_dmuerr
private

Definition at line 67 of file TileCellSelector.h.

◆ m_dqerr

unsigned int TileCellSelector::m_dqerr
private

Definition at line 66 of file TileCellSelector.h.

◆ m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileCellSelector::m_dqStatusKey {this, "TileDQstatus", "TileDQstatus", "TileDQstatus key"}
private

Definition at line 74 of file TileCellSelector.h.

◆ m_drawer

std::vector<int> TileCellSelector::m_drawer
private

Definition at line 170 of file TileCellSelector.h.

◆ m_drawerToCheck

std::vector<int> TileCellSelector::m_drawerToCheck
private

Definition at line 171 of file TileCellSelector.h.

◆ m_drawerToSkip

std::vector<bool> TileCellSelector::m_drawerToSkip
private

Definition at line 105 of file TileCellSelector.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TileCellSelector::m_eventInfoKey
private
Initial value:
{this,"EventInfo",
"EventInfo", "Input event info key"}

Definition at line 121 of file TileCellSelector.h.

◆ m_evtBCID

unsigned int TileCellSelector::m_evtBCID
private

Definition at line 80 of file TileCellSelector.h.

◆ m_evtNum

unsigned int TileCellSelector::m_evtNum
private

Definition at line 79 of file TileCellSelector.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_infoName

std::string TileCellSelector::m_infoName
private

Definition at line 177 of file TileCellSelector.h.

◆ m_jump

unsigned int TileCellSelector::m_jump
private

Definition at line 60 of file TileCellSelector.h.

◆ m_jumpDeltaHG

float TileCellSelector::m_jumpDeltaHG
private

Definition at line 144 of file TileCellSelector.h.

◆ m_jumpDeltaLG

float TileCellSelector::m_jumpDeltaLG
private

Definition at line 145 of file TileCellSelector.h.

◆ m_lumiBlock

unsigned int TileCellSelector::m_lumiBlock
private

Definition at line 78 of file TileCellSelector.h.

◆ m_maxBadDMU

int TileCellSelector::m_maxBadDMU
private

Definition at line 150 of file TileCellSelector.h.

◆ m_maxCell

unsigned int TileCellSelector::m_maxCell
private

Definition at line 57 of file TileCellSelector.h.

◆ m_maxChan

unsigned int TileCellSelector::m_maxChan
private

Definition at line 59 of file TileCellSelector.h.

◆ m_maxEneCell

float TileCellSelector::m_maxEneCell
private

Definition at line 125 of file TileCellSelector.h.

◆ m_maxEneChan

float TileCellSelector::m_maxEneChan[3] {}
private

Definition at line 127 of file TileCellSelector.h.

◆ m_maxTimeCell

float TileCellSelector::m_maxTimeCell
private

Definition at line 129 of file TileCellSelector.h.

◆ m_maxTimeChan

float TileCellSelector::m_maxTimeChan[3] {}
private

Definition at line 131 of file TileCellSelector.h.

◆ m_maxVerboseCnt

int TileCellSelector::m_maxVerboseCnt
private

Definition at line 174 of file TileCellSelector.h.

◆ m_minBadDMU

int TileCellSelector::m_minBadDMU
private

Definition at line 149 of file TileCellSelector.h.

◆ m_minBadMB

int TileCellSelector::m_minBadMB
private

Definition at line 151 of file TileCellSelector.h.

◆ m_minCell

unsigned int TileCellSelector::m_minCell
private

Definition at line 56 of file TileCellSelector.h.

◆ m_minChan

unsigned int TileCellSelector::m_minChan
private

Definition at line 58 of file TileCellSelector.h.

◆ m_minEneCell

float TileCellSelector::m_minEneCell
private

Definition at line 124 of file TileCellSelector.h.

◆ m_minEneChan

float TileCellSelector::m_minEneChan[3] {}
private

Definition at line 126 of file TileCellSelector.h.

◆ m_minTimeCell

float TileCellSelector::m_minTimeCell
private

Definition at line 128 of file TileCellSelector.h.

◆ m_minTimeChan

float TileCellSelector::m_minTimeChan[3] {}
private

Definition at line 130 of file TileCellSelector.h.

◆ m_nDrawerOff

std::vector<int> TileCellSelector::m_nDrawerOff
private

Definition at line 175 of file TileCellSelector.h.

◆ m_overflowHG

float TileCellSelector::m_overflowHG
private

Definition at line 163 of file TileCellSelector.h.

◆ m_overflowLG

float TileCellSelector::m_overflowLG
private

Definition at line 162 of file TileCellSelector.h.

◆ m_overHG

unsigned int TileCellSelector::m_overHG
private

Definition at line 63 of file TileCellSelector.h.

◆ m_overLG

unsigned int TileCellSelector::m_overLG
private

Definition at line 62 of file TileCellSelector.h.

◆ m_pedDeltaHG

float TileCellSelector::m_pedDeltaHG
private

Definition at line 146 of file TileCellSelector.h.

◆ m_pedDeltaLG

float TileCellSelector::m_pedDeltaLG
private

Definition at line 147 of file TileCellSelector.h.

◆ m_printOnly

bool TileCellSelector::m_printOnly
private

Definition at line 168 of file TileCellSelector.h.

◆ m_ptnEneCell

int TileCellSelector::m_ptnEneCell
private

Definition at line 132 of file TileCellSelector.h.

◆ m_ptnEneChan

int TileCellSelector::m_ptnEneChan[3] {}
private

Definition at line 133 of file TileCellSelector.h.

◆ m_ptnTimeCell

int TileCellSelector::m_ptnTimeCell
private

Definition at line 134 of file TileCellSelector.h.

◆ m_ptnTimeChan

int TileCellSelector::m_ptnTimeChan[3] {}
private

Definition at line 135 of file TileCellSelector.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileCellSelector::m_rawChannelContainerKey
private
Initial value:
{this,"RawChannelContainerName",
"TileRawChannelCnt",
"Input Tile raw channel container key"}

Definition at line 117 of file TileCellSelector.h.

◆ m_readCells

bool TileCellSelector::m_readCells
private

Definition at line 107 of file TileCellSelector.h.

◆ m_readDigits

bool TileCellSelector::m_readDigits
private

Definition at line 109 of file TileCellSelector.h.

◆ m_readRawChannels

bool TileCellSelector::m_readRawChannels
private

Definition at line 108 of file TileCellSelector.h.

◆ m_runNum

unsigned int TileCellSelector::m_runNum
private

Definition at line 77 of file TileCellSelector.h.

◆ m_secondMaxLevel

float TileCellSelector::m_secondMaxLevel
private

Definition at line 143 of file TileCellSelector.h.

◆ m_selectGain

int TileCellSelector::m_selectGain
private

Definition at line 136 of file TileCellSelector.h.

◆ m_skipEmpty

bool TileCellSelector::m_skipEmpty
private

Definition at line 152 of file TileCellSelector.h.

◆ m_skipGain

bool TileCellSelector::m_skipGain[2] {}
private

Definition at line 137 of file TileCellSelector.h.

◆ m_skipMasked

bool TileCellSelector::m_skipMasked
private

Definition at line 153 of file TileCellSelector.h.

◆ m_skipMBTS

bool TileCellSelector::m_skipMBTS
private

Definition at line 154 of file TileCellSelector.h.

◆ m_tileBadChanTool

ToolHandle<ITileBadChanTool> TileCellSelector::m_tileBadChanTool {this, "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}
private

Definition at line 73 of file TileCellSelector.h.

◆ m_tileDCS

ToolHandle<ITileDCSTool> TileCellSelector::m_tileDCS {this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"}
private

Definition at line 75 of file TileCellSelector.h.

◆ m_tileError

unsigned int TileCellSelector::m_tileError
private

Definition at line 95 of file TileCellSelector.h.

◆ m_tileFlag

unsigned int TileCellSelector::m_tileFlag
private

Definition at line 93 of file TileCellSelector.h.

◆ m_tileHWID

const TileHWID* TileCellSelector::m_tileHWID
private

Definition at line 71 of file TileCellSelector.h.

◆ m_tileID

const TileID* TileCellSelector::m_tileID
private

Definition at line 70 of file TileCellSelector.h.

◆ m_tileInfo

const TileInfo* TileCellSelector::m_tileInfo
private

Definition at line 178 of file TileCellSelector.h.

◆ m_underflowHG

float TileCellSelector::m_underflowHG
private

Definition at line 165 of file TileCellSelector.h.

◆ m_underflowLG

float TileCellSelector::m_underflowLG
private

Definition at line 164 of file TileCellSelector.h.

◆ m_underHG

unsigned int TileCellSelector::m_underHG
private

Definition at line 65 of file TileCellSelector.h.

◆ m_underLG

unsigned int TileCellSelector::m_underLG
private

Definition at line 64 of file TileCellSelector.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_warnerr

unsigned int TileCellSelector::m_warnerr
private

Definition at line 68 of file TileCellSelector.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
TileCell
Definition: TileCell.h:57
TileCellSelector::m_skipMasked
bool m_skipMasked
Definition: TileCellSelector.h:153
TileRawChannelBuilder::CorruptedData
static int CorruptedData(int ros, int drawer, int channel, int gain, const std::vector< float > &digits, float &dmin, float &dmax, float ADCmaxMinusEps, float ADCmaskValueMinusEps)
Definition: TileRawChannelBuilder.cxx:723
EventInfo::Error
@ Error
Definition: EventInfo/EventInfo/EventInfo.h:60
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
TileCellSelector::m_drawerToSkip
std::vector< bool > m_drawerToSkip
Definition: TileCellSelector.h:105
TileCellSelector::m_ptnTimeChan
int m_ptnTimeChan[3]
Definition: TileCellSelector.h:135
TileCell::time1
float time1(void) const
get time of first PMT
Definition: TileCell.h:198
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TileCellSelector::m_minBadMB
int m_minBadMB
Definition: TileCellSelector.h:151
TileCellSelector::m_overflowLG
float m_overflowLG
Definition: TileCellSelector.h:162
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
TileCellSelector::m_warnerr
unsigned int m_warnerr
Definition: TileCellSelector.h:68
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
EventInfo::Warning
@ Warning
Definition: EventInfo/EventInfo/EventInfo.h:60
TileCellSelector::m_maxTimeChan
float m_maxTimeChan[3]
Definition: TileCellSelector.h:131
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileCellSelector::m_runNum
unsigned int m_runNum
Definition: TileCellSelector.h:77
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileCell::time2
float time2(void) const
get time of second PMT
Definition: TileCell.h:200
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ReadCellNoiseFromCool.cellmax
cellmax
Definition: ReadCellNoiseFromCool.py:213
TileCellSelector::m_drawer
std::vector< int > m_drawer
Definition: TileCellSelector.h:170
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
ReadCalibFromCool.chmax
chmax
Definition: ReadCalibFromCool.py:488
TileCell::ene1
float ene1(void) const
get energy of first PMT
Definition: TileCell.h:193
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileCell::badch1
bool badch1(void) const
check if first PMT is in bad channel list and masked
Definition: TileCell.h:215
TileHWID::channel_context
IdContext channel_context(void) const
idContext for channels
Definition: TileHWID.cxx:477
TileCellSelector::m_jumpDeltaLG
float m_jumpDeltaLG
Definition: TileCellSelector.h:145
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileCellSelector::m_dqerr
unsigned int m_dqerr
Definition: TileCellSelector.h:66
TileCellSelector::m_pedDeltaLG
float m_pedDeltaLG
Definition: TileCellSelector.h:147
EventInfo::Tile
@ Tile
Definition: EventInfo/EventInfo/EventInfo.h:54
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ptnlength
#define ptnlength
Definition: TileCellSelector.h:138
TileCellSelector::m_minChan
unsigned int m_minChan
Definition: TileCellSelector.h:58
TileCellSelector::m_jumpDeltaHG
float m_jumpDeltaHG
Definition: TileCellSelector.h:144
Tile_Base_ID::HIGHGAIN
@ HIGHGAIN
Definition: Tile_Base_ID.h:57
TileCellSelector::m_maxVerboseCnt
int m_maxVerboseCnt
Definition: TileCellSelector.h:174
TileCellSelector::m_chanEne
std::vector< float > m_chanEne
Definition: TileCellSelector.h:98
TileCablingService::h2s_cell_id_index
Identifier h2s_cell_id_index(const HWIdentifier &id, int &index, int &pmt) const
Definition: TileCablingService.cxx:2418
TileCellSelector::m_checkDCS
bool m_checkDCS
Definition: TileCellSelector.h:155
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileCellSelector::m_dmuerr
unsigned int m_dmuerr
Definition: TileCellSelector.h:67
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
CaloCell::time
float time() const
get time (data member)
Definition: CaloCell.h:352
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
TileCellSelector::m_pedDeltaHG
float m_pedDeltaHG
Definition: TileCellSelector.h:146
TileDQstatus::isChEmpty
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
TileCellSelector::m_counter
unsigned int m_counter
Definition: TileCellSelector.h:54
TileCellSelector::m_checkUnderLG
bool m_checkUnderLG
Definition: TileCellSelector.h:160
TileCellSelector::m_evtNum
unsigned int m_evtNum
Definition: TileCellSelector.h:79
TileRawChannel::time
float time(int ind=0) const
Definition: TileRawChannel.h:103
TileCellSelector::m_minTimeCell
float m_minTimeCell
Definition: TileCellSelector.h:128
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileCellSelector::m_constLength
int m_constLength
Definition: TileCellSelector.h:148
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileCellSelector::m_maxCell
unsigned int m_maxCell
Definition: TileCellSelector.h:57
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
ReadCellNoiseFromCool.cellmin
cellmin
Definition: ReadCellNoiseFromCool.py:212
TileCellSelector::m_underflowLG
float m_underflowLG
Definition: TileCellSelector.h:164
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
CaloCell::energy
double energy() const
get energy (data member)
Definition: CaloCell.h:311
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
TileCellSelector::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: TileCellSelector.h:121
TileInfo::ADCmaskValue
int ADCmaskValue() const
Returns the overlay magic number that indicates channels which were masked in background dataset.
Definition: TileInfo.h:73
TileCellSelector::m_checkDMUs
bool m_checkDMUs
Definition: TileCellSelector.h:157
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
TileCellSelector::m_chanSel
std::vector< bool > m_chanSel
Definition: TileCellSelector.h:103
TileCellSelector::m_skipGain
bool m_skipGain[2]
Definition: TileCellSelector.h:137
TileCellSelector::m_secondMaxLevel
float m_secondMaxLevel
Definition: TileCellSelector.h:143
TileCellSelector::m_chanToCheck
std::vector< int > m_chanToCheck
Definition: TileCellSelector.h:172
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileCell::qual2
uint8_t qual2(void) const
get quality of second PMT (data member)
Definition: TileCell.h:206
TileCellSelector::m_tileDCS
ToolHandle< ITileDCSTool > m_tileDCS
Definition: TileCellSelector.h:75
TileDCSDataPlotter.tit
tit
Definition: TileDCSDataPlotter.py:890
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileCellSelector::m_maxEneChan
float m_maxEneChan[3]
Definition: TileCellSelector.h:127
TileCellSelector::m_maxBadDMU
int m_maxBadDMU
Definition: TileCellSelector.h:150
TileCellSelector::m_tileID
const TileID * m_tileID
Definition: TileCellSelector.h:70
TileCellSelector::m_minTimeChan
float m_minTimeChan[3]
Definition: TileCellSelector.h:130
TileCellSelector::m_printOnly
bool m_printOnly
Definition: TileCellSelector.h:168
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
python.changerun.m1
m1
Definition: changerun.py:32
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileCellSelector::m_nDrawerOff
std::vector< int > m_nDrawerOff
Definition: TileCellSelector.h:175
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
ReadCalibFromCool.chmin
chmin
Definition: ReadCalibFromCool.py:487
lumiFormat.i
int i
Definition: lumiFormat.py:92
TileCellSelector::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: TileCellSelector.h:111
TileHWID::get_hash
virtual IdentifierHash get_hash(const HWIdentifier &id) const
create hash id from compact ADC id without error checking
Definition: TileHWID.cxx:543
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
01SubmitToGrid.samples
samples
Definition: 01SubmitToGrid.py:58
TileCellSelector::m_chanTime
std::vector< float > m_chanTime
Definition: TileCellSelector.h:99
TileCell::MASK_OVER
@ MASK_OVER
Definition: TileCell.h:64
TileCellSelector::m_checkWarning
bool m_checkWarning
Definition: TileCellSelector.h:166
TileCell::badch2
bool badch2(void) const
check if second PMT is in bad channel list and masked
Definition: TileCell.h:218
python.getCurrentFolderTag.dn
dn
Definition: getCurrentFolderTag.py:64
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
TileRawChannel
Definition: TileRawChannel.h:35
TileCellSelector::m_ptnTimeCell
int m_ptnTimeCell
Definition: TileCellSelector.h:134
TileCell::MASK_CMPC
@ MASK_CMPC
Definition: TileCell.h:66
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TileCellSelector::m_checkOverLG
bool m_checkOverLG
Definition: TileCellSelector.h:158
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
Tile_Base_ID::LOWGAIN
@ LOWGAIN
Definition: Tile_Base_ID.h:57
TileCellSelector::m_const
unsigned int m_const
Definition: TileCellSelector.h:61
TileCell::qbit1
uint8_t qbit1(void) const
get quality bits of first PMT (data member)
Definition: TileCell.h:209
TileCellSelector::m_accept
unsigned int m_accept
Definition: TileCellSelector.h:55
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileCellSelector::m_drawerToCheck
std::vector< int > m_drawerToCheck
Definition: TileCellSelector.h:171
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileCellSelector::m_skipEmpty
bool m_skipEmpty
Definition: TileCellSelector.h:152
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileCellSelector::m_bitTimeCell
bool m_bitTimeCell[ptnlength]
Definition: TileCellSelector.h:140
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
ReadCellNoiseFromCool.dm
dm
Definition: ReadCellNoiseFromCool.py:235
TileCellSelector::m_checkJumps
bool m_checkJumps
Definition: TileCellSelector.h:156
min
#define min(a, b)
Definition: cfImp.cxx:40
TileCellSelector::m_bitTimeChan
bool m_bitTimeChan[3][ptnlength]
Definition: TileCellSelector.h:142
TileRawDataCollection::identify
ID identify() const
Definition: TileRawDataCollection.h:71
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TileCellSelector::m_bitEneCell
bool m_bitEneCell[ptnlength]
Definition: TileCellSelector.h:139
TileCellSelector::m_maxEneCell
float m_maxEneCell
Definition: TileCellSelector.h:125
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TileCellSelector::m_chanQua
std::vector< float > m_chanQua
Definition: TileCellSelector.h:102
TileDigitsCollection
Definition: TileDigitsCollection.h:18
TileCellSelector::m_underflowHG
float m_underflowHG
Definition: TileCellSelector.h:165
TileHWID::drawer_id
HWIdentifier drawer_id(int frag) const
ROS HWIdentifer.
Definition: TileHWID.cxx:186
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TileCellSelector::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileCellSelector.h:74
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TileDigits
Definition: TileDigits.h:30
TileCellSelector::m_readCells
bool m_readCells
Definition: TileCellSelector.h:107
TileHWID::channel_id
HWIdentifier channel_id(int ros, int drawer, int channel) const
channel HWIdentifer
Definition: TileHWID.cxx:198
TileDCSState::ALERT_DRAWER
@ ALERT_DRAWER
Definition: TileDCSState.h:35
TileRawChannelCollection
Definition: TileRawChannelCollection.h:12
TileCellSelector::m_lumiBlock
unsigned int m_lumiBlock
Definition: TileCellSelector.h:78
TileCellSelector::m_overHG
unsigned int m_overHG
Definition: TileCellSelector.h:63
TileCellSelector::m_overLG
unsigned int m_overLG
Definition: TileCellSelector.h:62
CaloCell::ID
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
Definition: CaloCell.h:279
ReadBadBitsFromCool.warn
warn
Definition: ReadBadBitsFromCool.py:43
TileCellSelector::m_tileFlag
unsigned int m_tileFlag
Definition: TileCellSelector.h:93
TileCellSelector::m_selectGain
int m_selectGain
Definition: TileCellSelector.h:136
TileCellSelector::m_ADCmaskValueMinusEps
float m_ADCmaskValueMinusEps
Definition: TileCellSelector.h:180
Example_ReadSampleNoise.ped
ped
Definition: Example_ReadSampleNoise.py:45
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
TileCellSelector::m_minEneCell
float m_minEneCell
Definition: TileCellSelector.h:124
TileCell::qbit2
uint8_t qbit2(void) const
get quality bits of second PMT (data member)
Definition: TileCell.h:212
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TileCell::gain2
int gain2(void) const
get gain of second PMT
Definition: TileCell.cxx:189
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileCell::ene2
float ene2(void) const
get energy of second PMT
Definition: TileCell.h:195
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
TileCellSelector::m_checkUnderHG
bool m_checkUnderHG
Definition: TileCellSelector.h:161
a
TList * a
Definition: liststreamerinfos.cxx:10
TileCellSelector::m_underHG
unsigned int m_underHG
Definition: TileCellSelector.h:65
h
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
Tile_Base_ID::to_string
std::string to_string(const Identifier &id, int level=0) const
Definition: Tile_Base_ID.cxx:52
lumiFormat.fill
fill
Definition: lumiFormat.py:111
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileCellSelector::m_chanToSkip
std::vector< bool > m_chanToSkip
Definition: TileCellSelector.h:104
TileCellSelector::m_minEneChan
float m_minEneChan[3]
Definition: TileCellSelector.h:126
TileCellSelector::m_overflowHG
float m_overflowHG
Definition: TileCellSelector.h:163
TileCellSelector::Are3FF
int Are3FF(std::vector< float > &OptFilterDigits, int OptFilterGain, int ch_type)
Definition: TileCellSelector.cxx:2111
TileCellSelector::m_tileError
unsigned int m_tileError
Definition: TileCellSelector.h:95
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileCellSelector::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileCellSelector.h:71
TileCellSelector::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileCellSelector.h:114
TileCellSelector::m_maxTimeCell
float m_maxTimeCell
Definition: TileCellSelector.h:129
TileCellSelector::m_chanBad
std::vector< bool > m_chanBad
Definition: TileCellSelector.h:97
TileCellSelector::m_checkError
bool m_checkError
Definition: TileCellSelector.h:167
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TileCellSelector::m_rawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
Definition: TileCellSelector.h:117
TileCellSelector::m_readRawChannels
bool m_readRawChannels
Definition: TileCellSelector.h:108
TileCellSelector::m_maxChan
unsigned int m_maxChan
Definition: TileCellSelector.h:59
TileCell::qual1
uint8_t qual1(void) const
get quality of first PMT (data member)
Definition: TileCell.h:203
TileDCSState::WARNING
@ WARNING
Definition: TileDCSState.h:34
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TileCellSelector::m_minCell
unsigned int m_minCell
Definition: TileCellSelector.h:56
TileCellSelector::m_ptnEneChan
int m_ptnEneChan[3]
Definition: TileCellSelector.h:133
TileCellSelector::m_chanTDsp
std::vector< float > m_chanTDsp
Definition: TileCellSelector.h:101
TileCellSelector::m_readDigits
bool m_readDigits
Definition: TileCellSelector.h:109
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
TileCellSelector::m_chanDsp
std::vector< float > m_chanDsp
Definition: TileCellSelector.h:100
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
rr
const boost::regex rr(r_r)
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TileAANtupleConfig.rawChannelContainer
rawChannelContainer
Definition: TileAANtupleConfig.py:120
TileHWID::to_string
std::string to_string(const HWIdentifier &id, int level=0) const
extract all fields from HW identifier HWIdentifier get_all_fields ( const HWIdentifier & id,...
Definition: TileHWID.cxx:49
TileCellSelector::m_ADCmaxMinusEps
float m_ADCmaxMinusEps
Definition: TileCellSelector.h:179
TileCellSelector::m_underLG
unsigned int m_underLG
Definition: TileCellSelector.h:64
IdentifierHash
Definition: IdentifierHash.h:38
TileCellSelector::m_skipMBTS
bool m_skipMBTS
Definition: TileCellSelector.h:154
get_generator_info.error
error
Definition: get_generator_info.py:40
TileCellSelector::m_bitEneChan
bool m_bitEneChan[3][ptnlength]
Definition: TileCellSelector.h:141
TileCellSelector::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition: TileCellSelector.h:73
TileCellSelector::m_tileInfo
const TileInfo * m_tileInfo
Definition: TileCellSelector.h:178
error
Definition: IImpactPoint3dEstimator.h:70
IdContext
class IdContext
Definition: IdContext.h:34
TileCellSelector::m_cabling
const TileCablingService * m_cabling
Definition: TileCellSelector.h:72
TileCellSelector::m_jump
unsigned int m_jump
Definition: TileCellSelector.h:60
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
nmax
const int nmax(200)
TileInfo::ADCmax
int ADCmax() const
Returns the maximum ADC output (10 bits --> 1023)
Definition: TileInfo.h:71
TileCellSelector::m_minBadDMU
int m_minBadDMU
Definition: TileCellSelector.h:149
fitman.k
k
Definition: fitman.py:528
TileRawChannelUnit::OnlineMegaElectronVolts
@ OnlineMegaElectronVolts
Definition: TileRawChannelUnit.h:24
TileCellSelector::m_evtBCID
unsigned int m_evtBCID
Definition: TileCellSelector.h:80
TileCellSelector::m_checkOverHG
bool m_checkOverHG
Definition: TileCellSelector.h:159
TileCellSelector::m_infoName
std::string m_infoName
Definition: TileCellSelector.h:177
ServiceHandle< ICondSvc >
TileCellSelector::m_ptnEneCell
int m_ptnEneCell
Definition: TileCellSelector.h:132
Generated on Fri Jul 5 2024 22:01:51 for ATLAS Offline Software by   doxygen 1.8.18