ATLAS Offline Software
Loading...
Searching...
No Matches
TileDigitsFilter Class Reference

This algorithm copies TileDigits from input container to output container keeping only channels with (max-min) sample above threshold. More...

#include <TileDigitsFilter.h>

Inheritance diagram for TileDigitsFilter:
Collaboration diagram for TileDigitsFilter:

Public Member Functions

 TileDigitsFilter (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~TileDigitsFilter ()
virtual StatusCode initialize () override
 initialize method
virtual StatusCode execute (const EventContext &ctx) const override
 execute method
virtual StatusCode finalize () override
 finalize method
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

SG::ReadHandleKey< TileDigitsContainer > m_inputDigitsContainerKey
SG::WriteHandleKey< TileDigitsContainer > m_outputDigitsContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_inputRawChannelContainerKey
SG::WriteHandleKey< TileRawChannelContainer > m_outputRawChannelContainerKey
Gaudi::Property< int > m_lowGainThreashold
Gaudi::Property< int > m_highGainThreashold
const TileHWID * m_tileHWID {nullptr}
ServiceHandle< TileCablingSvc > m_cablingSvc
 Name of Tile cabling service.
int m_threshold [2] {}
 Threshold value for low and high gain.
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

This algorithm copies TileDigits from input container to output container keeping only channels with (max-min) sample above threshold.

Definition at line 55 of file TileDigitsFilter.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileDigitsFilter()

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

Definition at line 37 of file TileDigitsFilter.cxx.

38 : AthReentrantAlgorithm(name, pSvcLocator)
39{
40}

◆ ~TileDigitsFilter()

TileDigitsFilter::~TileDigitsFilter ( )
virtual

Definition at line 42 of file TileDigitsFilter.cxx.

42 {
43}

Member Function Documentation

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode TileDigitsFilter::execute ( const EventContext & ctx) const
overridevirtual

execute method

Definition at line 92 of file TileDigitsFilter.cxx.

92 {
93
94 ATH_MSG_DEBUG( "in execute()" );
95
96 int digCounter = 0;
97 int rchCounter = 0;
98
99
100 // Create new container for filtered digits
101 auto outputCont = std::make_unique<TileDigitsContainer>(false, SG::VIEW_ELEMENTS);
102 if (!outputCont) {
103 ATH_MSG_FATAL( "Could not create a new TileDigitsContainer instance as requested!" );
104 return StatusCode::FAILURE;
105 }
106
107 // Initialize iterators to some dummy values
108 TileDigitsContainer::const_iterator collItr, lastColl;
109 collItr = lastColl = outputCont->end();
110
111 // Get digit container from TES
112 if (!m_inputDigitsContainerKey.key().empty()) {
113 SG::ReadHandle<TileDigitsContainer> inputDigitsContainer(m_inputDigitsContainerKey, ctx);
114
115 if (inputDigitsContainer.isValid()) {
116 collItr = inputDigitsContainer->begin();
117 lastColl = inputDigitsContainer->end();
118 } else {
119 ATH_MSG_WARNING( "can't retrieve TileDigitsContainer with name '"
120 << m_inputDigitsContainerKey.key() << "' from TDS" );
121 }
122
123 }
124
125 TileRawChannelContainer::const_iterator firstRchColl, lastRchColl, collRchItr;
128 bool emptyRch = true;
129
130 // Get rawChannel container from TES
131 if (!m_inputRawChannelContainerKey.key().empty()) {
132 SG::ReadHandle<TileRawChannelContainer> inputRawChannelContainer(m_inputRawChannelContainerKey, ctx);
133
134 if (inputRawChannelContainer.isValid()) {
135 collRchItr = firstRchColl = inputRawChannelContainer->begin();
136 lastRchColl = inputRawChannelContainer->end();
137 emptyRch = (firstRchColl == lastRchColl);
138 type = inputRawChannelContainer->get_type();
139 unit = inputRawChannelContainer->get_unit();
140 } else {
141 ATH_MSG_WARNING( "can't retrieve TileRawChannelContainer with name '"
142 << m_inputRawChannelContainerKey.key() << "' from TDS" );
143 }
144
145 }
146
147 // Create new container for filtered raw channels
148 auto outRchCont = std::make_unique<TileRawChannelContainer>(false, type, unit, SG::VIEW_ELEMENTS);
149
150 // Iterate over all collections (drawers)
151 for (; collItr != lastColl; ++collItr) {
152
153 const TileDigitsCollection* coll = *collItr;
154 std::set<HWIdentifier> ids;
155
156 auto outColl = std::make_unique<ConstDataVector<TileDigitsCollection> >
157 (SG::VIEW_ELEMENTS, coll->identify());
158
159 // Iterate over all digits in this collection
160 for (const TileDigits* digit : *coll) {
161 float smin = 99999., smax = -99999.;
162 for (float samp : digit->samples()) {
163 smin = std::min(samp, smin);
164 smax = std::max(samp, smax);
165 }
166 HWIdentifier adcId = digit->adc_HWID();
167 if (smax - smin > m_threshold[m_tileHWID->adc(adcId)]) {
168 outColl->push_back(digit);
169 ids.insert(adcId);
170 ++digCounter;
171 if (msgLvl(MSG::VERBOSE)) {
172 msg(MSG::VERBOSE) << (m_tileHWID->adc(adcId) ? " HG " : " LG ")
173 << "id=" << m_tileHWID->to_string(adcId)
174 << " samples=";
175
176 for (float samp : digit->samples()) {
177 msg(MSG::VERBOSE) << " " << samp;
178 }
179
180 msg(MSG::VERBOSE) << endmsg;
181 }
182 }
183
184 // else if (msgLvl(MSG::VERBOSE)){
185 // msg(MSG::VERBOSE) << "Filtered Out "
186 // << (m_tileHWID->adc(adcId) ? " HG " : " LG ")
187 // << "id=" << m_tileHWID->to_string(adcId)
188 // << " samples=";
189 // for(idig=digits.begin(); idig!=iend; ++idig)
190 // msg(MSG::VERBOSE) << " " << (*idig);
191 //
192 // msg(MSG::VERBOSE) << endmsg;
193 // }
194
195 }
196
197 ATH_CHECK( outputCont->addCollection (outColl.release()->asDataVector(),
198 collItr.hashId()) );
199
200 if (ids.size() == 0 || emptyRch)
201 continue;
202
203 while (collRchItr != lastRchColl
204 && (*collRchItr)->identify() < (*collItr)->identify()) {
205 ++collRchItr;
206 }
207 if (collRchItr == lastRchColl) {
208 ATH_MSG_WARNING( MSG::hex
209 << "TileDigitsCollection ID 0x" << (*collItr)->identify()
210 << " but corresponding TileRawChannelCollection is missing"
211 << MSG::dec );
212
213 } else if ((*collItr)->identify() != (*collRchItr)->identify()) {
214 ATH_MSG_WARNING( MSG::hex
215 << "TileDigitsCollection ID 0x" << (*collItr)->identify()
216 << " and TileRawChannelCollection ID 0x" << (*collRchItr)->identify()
217 << " do not match " << MSG::dec );
218
219 } else {
220 const TileRawChannelCollection* collRch = *collRchItr;
221 auto outRchColl = std::make_unique<ConstDataVector<TileRawChannelCollection> >
222 (SG::VIEW_ELEMENTS, collRch->identify());
223
224 // Iterate over all rawChannels in this collection
225 for (const TileRawChannel* rch : *collRch) {
226 HWIdentifier adcId = rch->adc_HWID();
227 if (ids.find(adcId) != ids.end()) {
228 outRchColl->push_back (rch);
229 ++rchCounter;
230 ATH_MSG_VERBOSE( (m_tileHWID->adc(adcId) ? " HG " : " LG ")
231 << "id=" << m_tileHWID->to_string(adcId)
232 << " amp=" << rch->amplitude() );
233 }
234 }
235 ATH_CHECK( outRchCont->addCollection (outRchColl.release()->asDataVector(),
236 collRchItr.hashId()) );
237 }
238 }
239
240 ATH_MSG_DEBUG( digCounter << " digits and "
241 << rchCounter << " raw channels stored in output containers");
242
243 if (!m_outputDigitsContainerKey.key().empty()) {
244 // register new container in the TES
245 SG::WriteHandle<TileDigitsContainer> outputDigitsContainer(m_outputDigitsContainerKey, ctx);
246 ATH_CHECK( outputDigitsContainer.record(std::move(outputCont)) );
247
248 ATH_MSG_DEBUG( "TileDigitsContainer registered successfully (" << m_outputDigitsContainerKey.key() << ")");
249
250 }
251
252 if (!m_outputRawChannelContainerKey.key().empty()) {
253 // register new container in the TES
254 SG::WriteHandle<TileRawChannelContainer> outputRawChannelContainer(m_outputRawChannelContainerKey, ctx);
255 ATH_CHECK( outputRawChannelContainer.record(std::move(outRchCont)) );
256
257 ATH_MSG_DEBUG( "TileRawChannelContainer registered successfully ("
258 << m_outputRawChannelContainerKey.key() << ")");
259 }
260
261 // Execution completed.
262 ATH_MSG_DEBUG( "execution completed" );
263
264 return StatusCode::SUCCESS;
265}
#define endmsg
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
#define ATH_MSG_FATAL(x,...)
detray::unit< scalar_t > unit
bool msgLvl(const MSG::Level lvl) const
IdentifierHash hashId() const
hashId of the pointed-to element
SG::WriteHandleKey< TileDigitsContainer > m_outputDigitsContainerKey
SG::WriteHandleKey< TileRawChannelContainer > m_outputRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_inputRawChannelContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_inputDigitsContainerKey
const TileHWID * m_tileHWID
int m_threshold[2]
Threshold value for low and high gain.
TYPE
initialize
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:

◆ finalize()

StatusCode TileDigitsFilter::finalize ( )
overridevirtual

finalize method

Definition at line 267 of file TileDigitsFilter.cxx.

267 {
268
269 ATH_MSG_INFO( "in finalize()" );
270
271 return StatusCode::SUCCESS;
272}
#define ATH_MSG_INFO(x,...)

◆ initialize()

StatusCode TileDigitsFilter::initialize ( )
overridevirtual

initialize method

Definition at line 48 of file TileDigitsFilter.cxx.

48 {
49
50 ATH_CHECK( m_cablingSvc.retrieve() );
51
52 ATH_CHECK( detStore()->retrieve(m_tileHWID) );
53
54 ATH_MSG_INFO( "Input digits container: '" << m_inputDigitsContainerKey.key()
55 << "' output container: '" << m_outputDigitsContainerKey.key() << "'" );
56
57 ATH_MSG_INFO( "Input raw channel container: '" << m_inputRawChannelContainerKey.key()
58 << "' output container: '" << m_outputRawChannelContainerKey.key() << "'" );
59
62
63 ATH_MSG_INFO( "Threshold low gain: " << m_threshold[0]
64 << " counts, high gain: " << m_threshold[1] << " counts" );
65
66
67 if (!m_inputDigitsContainerKey.key().empty()) {
69 }
70
71 if (!m_outputDigitsContainerKey.key().empty()) {
73 }
74
75 if (!m_inputRawChannelContainerKey.key().empty()) {
77 }
78
79 if (!m_outputRawChannelContainerKey.key().empty()) {
81 }
82
83
84 ATH_MSG_INFO( "initialization completed" );
85
86 return StatusCode::SUCCESS;
87}
const ServiceHandle< StoreGateSvc > & detStore() const
Gaudi::Property< int > m_highGainThreashold
Gaudi::Property< int > m_lowGainThreashold
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ setFilterPassed()

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

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ sysExecute()

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

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
#define ATH_MSG_ERROR(x,...)
virtual StatusCode sysInitialize() override
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_cablingSvc

ServiceHandle<TileCablingSvc> TileDigitsFilter::m_cablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Name of Tile cabling service.

Definition at line 93 of file TileDigitsFilter.h.

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

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_highGainThreashold

Gaudi::Property<int> TileDigitsFilter::m_highGainThreashold
private
Initial value:
{this,
"HighGainThereshold", 10, "High gain threshold to keep digits"}

Definition at line 85 of file TileDigitsFilter.h.

85 {this,
86 "HighGainThereshold", 10, "High gain threshold to keep digits"}; // keep signals above ~128(106) MeV in A,BC(D) samplings

◆ m_inputDigitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileDigitsFilter::m_inputDigitsContainerKey
private
Initial value:
{this,
"InputDigitsContainer", "TileDigitsCnt", "Input Tile digits container key"}

Definition at line 70 of file TileDigitsFilter.h.

70 {this,
71 "InputDigitsContainer", "TileDigitsCnt", "Input Tile digits container key"};

◆ m_inputRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileDigitsFilter::m_inputRawChannelContainerKey
private
Initial value:
{this,
"InputRawChannelContainer", "TileRawChannelCnt", "Input Tile raw channels container key"}

Definition at line 76 of file TileDigitsFilter.h.

76 {this,
77 "InputRawChannelContainer", "TileRawChannelCnt", "Input Tile raw channels container key"};

◆ m_lowGainThreashold

Gaudi::Property<int> TileDigitsFilter::m_lowGainThreashold
private
Initial value:
{this,
"LowGainThereshold", 0, "Low gain threshold to keep digits"}

Definition at line 82 of file TileDigitsFilter.h.

82 {this,
83 "LowGainThereshold", 0, "Low gain threshold to keep digits"}; // keep all LG except zeros

◆ m_outputDigitsContainerKey

SG::WriteHandleKey<TileDigitsContainer> TileDigitsFilter::m_outputDigitsContainerKey
private
Initial value:
{this,
"OutputDigitsContainer", "TileDigitsFlt","Output Tile digits container key"}

Definition at line 73 of file TileDigitsFilter.h.

73 {this,
74 "OutputDigitsContainer", "TileDigitsFlt","Output Tile digits container key"};

◆ m_outputRawChannelContainerKey

SG::WriteHandleKey<TileRawChannelContainer> TileDigitsFilter::m_outputRawChannelContainerKey
private
Initial value:
{this,
"OutputRawChannelContainer", "TileRawChannelFlt", "Output Tile digits container key"}

Definition at line 79 of file TileDigitsFilter.h.

79 {this,
80 "OutputRawChannelContainer", "TileRawChannelFlt", "Output Tile digits container key"};

◆ m_threshold

int TileDigitsFilter::m_threshold[2] {}
private

Threshold value for low and high gain.

Definition at line 96 of file TileDigitsFilter.h.

96{};

◆ m_tileHWID

const TileHWID* TileDigitsFilter::m_tileHWID {nullptr}
private

Definition at line 88 of file TileDigitsFilter.h.

88{nullptr};

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.


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