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

#include <TileRawChannelToTTL1.h>

Inheritance diagram for TileRawChannelToTTL1:
Collaboration diagram for TileRawChannelToTTL1:

Public Member Functions

 TileRawChannelToTTL1 (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~TileRawChannelToTTL1 ()
StatusCode initialize ()
StatusCode execute (const EventContext &ctx)
 Execute method.
StatusCode finalize ()
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

virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
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< TileRawChannelContainer > m_rawChannelContainerKey
SG::WriteHandleKey< TileTTL1Container > m_ttl1ContainerKey
Gaudi::Property< std::string > m_infoName {this, "TileInfoName", "TileInfo", "Name of TileInfo object in TES"}
Gaudi::Property< bool > m_constantTTL1shape {this, "TileConstantTTL1Shape", true, "Use constant TTL1 shape (phase=0 for all towers)"}
const TileID * m_tileID {nullptr}
const TileHWID * m_tileHWID {nullptr}
const TileInfo * m_tileInfo {nullptr}
const CaloLVL1_ID * m_TT_ID {nullptr}
std::vector< double > m_TTL1Shape
double m_phase {0}
int m_nSamp {0}
int m_iTrig {0}
ToolHandle< ITileBadChanTool > m_tileBadChanTool
 Tile Bad Channel tool.
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 main Tile Calibration tool
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

Definition at line 54 of file TileRawChannelToTTL1.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

◆ TileRawChannelToTTL1()

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

Definition at line 62 of file TileRawChannelToTTL1.cxx.

63 : AthAlgorithm(name, pSvcLocator)
64{
65}
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.

◆ ~TileRawChannelToTTL1()

TileRawChannelToTTL1::~TileRawChannelToTTL1 ( )
virtual

Definition at line 67 of file TileRawChannelToTTL1.cxx.

67 {
68}

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 TileRawChannelToTTL1::execute ( const EventContext & ctx)
virtual

Execute method.

Implements AthAlgorithm.

Definition at line 113 of file TileRawChannelToTTL1.cxx.

113 {
114
115 ATH_MSG_DEBUG( "Executing TileRawChannelToTTL1");
116
117 /*......................................................*/
118 // Step 2: Get all global parameters that will be needed for processing.
119 /* Get TileNoise flag from TileInfo (true => generate noise in TileDigits) */
120 bool tileNoise = m_tileInfo->TileNoise();
121 /* Get TileZeroSuppress flag from TileInfo
122 (true => apply threshold to Digits) */
123 bool tileThresh = m_tileInfo->TileZeroSuppress();
124 // declare array for random number generation for noise in samples.
125 double Rndm[16]; // Can't use variable size array
126 // declare TTL1 parameters to be obtained from TileInfo
127 float ttL1Calib, ttL1NoiseSigma, ttL1Ped, ttL1Thresh;
128
129 ATH_MSG_DEBUG( "nSamp=" << m_nSamp
130 << ", iTrig=" << m_iTrig
131 << ", tileNoise=" << ((tileNoise) ? "true" : "false")
132 << ", tileThresh=" << ((tileThresh) ? "true" : "false") );
133
134 /*......................................................*/
135 // step 3: Get rawChannel container from TES and create TTL1 container
136 /* Note that rawChannel container has 256 collections (one for each drawer),
137 but TTL1 container has no collections and no structure. */
138 SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(m_rawChannelContainerKey, ctx);
139 ATH_CHECK( rawChannelContainer.isValid() );
140
141 TileRawChannelUnit::UNIT rChUnit = rawChannelContainer->get_unit();
142 //TileFragHash::TYPE rChType = rawChannelContainer->get_type();
143
144 SG::WriteHandle<TileTTL1Container> ttl1Container(m_ttl1ContainerKey, ctx);
145 ATH_CHECK( ttl1Container.record(std::make_unique<TileTTL1Container>()) );
146 ATH_MSG_DEBUG( "TileTTL1Container registered successfully (" << m_ttl1ContainerKey.key() << ")" );
147
148 /*......................................................*/
149 // Step 4: Create temporary arrays for processing signals.
150 /* Create array for all TT amplitudes in a single drawer. */
151 Identifier ttId[16]; // array of TT identifiers in a single drawer
152 float ttAmp[16]; // array of all TT amplitudes in a single drawer
153 bool ttRawChannel[16]; // array of TT occupancy in a single drawer
154 int nTT; // number of rawChannel towers in this drawer.
155 int nRawChannel; // number of rawChannels in this drawer.
156 int nIgnore; // number of ignored rawChannels in this drawer.
157 int nTTTot = 0; // total number of rawChannel towers.
158 int nRawChannelTot = 0; // total number of rawChannels.
159 int nIgnoreTot = 0; // total number of ignored rawChannels.
160 float ttAmpTot = 0; // total energy in good level-1 towers.
161 float ttAmpTotIg = 0.; // total energy in "ignored" level-1 towers.
162 int minieta, maxieta, posneg;
163
164 /* Create array for the nSamp time-samples of a single tower. */
165 std::vector<float> ttL1samples(m_nSamp);
166
167 /*......................................................*/
168 // Step 5: Begin loop over all collections (collection = electronic drawer).
169 for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
170
171 HWIdentifier drawer_id = m_tileHWID->drawer_id(rawChannelCollection->identify());
172 int ros = m_tileHWID->ros(drawer_id);
173 int drawer = m_tileHWID->drawer(drawer_id);
174 int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
175
176 switch (ros) {
178 posneg = +1;
179 minieta = 0;
180 maxieta = 8;
181 break;
183 posneg = -1;
184 minieta = 0;
185 maxieta = 8;
186 break;
188 posneg = +1;
189 minieta = 9;
190 maxieta = 14;
191 break;
193 posneg = -1;
194 minieta = 9;
195 maxieta = 14;
196 break;
197 default:
198 posneg = minieta = maxieta = 0;
199 }
200
201 /* Zero temporary array of trigger tower amplitudes (TTL1amp) for this collection. */
202 memset(ttAmp, 0, sizeof(ttAmp));
203 memset(ttRawChannel, 0, sizeof(ttRawChannel));
204 nTT = nIgnore = nRawChannel = 0;
205
206 /*......................................................*/
207 // Step 6: Iterate over all rawChannels in this collection, summing amps for each tower.
208 for (const TileRawChannel* rawChannel : *rawChannelCollection) {
209
210 /* Get rawChannel Identifier */
211 HWIdentifier hwid = rawChannel->adc_HWID();
212 int channel = m_tileHWID->channel(hwid);
213 int adc = m_tileHWID->adc(hwid);
214
215 // note that amplitude() is in unknown units (can be even online MeV), convert it to MeV first
216 float e = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc,
217 rawChannel->amplitude(),
218 rChUnit,
220
221 // convert MeV to pCb
222 float q = e / m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
224
225 int ieta = 999;
226 int iphi = 999;
227
228 Identifier pmt_id = rawChannel->pmt_ID();
229 if (pmt_id.is_valid() && m_tileID->section(pmt_id) < 4
230 && m_tileID->section(pmt_id) > 0) {
231
232 /* Get TT Identifier for this pmt */
233 Identifier tt_id = rawChannel->tt_ID();
234 /* Get eta-phi indices of TTL1 for this channel. */
235 ieta = m_TT_ID->eta(tt_id);
236 iphi = m_TT_ID->phi(tt_id); // (same as module).
237 if (iphi != drawer)
238 ATH_MSG_ERROR( "drawer=" << drawer
239 << ", iphi=" << iphi
240 << "id=" << m_tileID->to_string(pmt_id) );
241
242 if (ttRawChannel[ieta]) { // already exists - just add charge
243 ttAmp[ieta] += q;
244 } else { // rawChannel in new TT
245 ttId[ieta] = tt_id;
246 ttRawChannel[ieta] = true;
247 ttAmp[ieta] = q;
248 if (ieta >= minieta && ieta <= maxieta)
249 ++nTT; // count only valid TT
250 }
251 ++nRawChannel;
252 if (ieta < minieta || ieta > maxieta)
253 ++nIgnore;
254 //Sum cell energy for comparison to other algos.
255 if (ieta >= minieta && ieta <= maxieta) {
256 ttAmpTot += e;
257 } else {
258 ttAmpTotIg += e;
259 }
260
261 if (msgLvl(MSG::VERBOSE)) {
262 /* Diagnostic checks: */
263 int side = m_tileID->side(pmt_id);
264 int tower = m_tileID->tower(pmt_id);
265 int sample = m_tileID->sample(pmt_id);
266 int pmt = m_tileID->pmt(pmt_id);
267 int channel = m_tileHWID->channel(hwid);
268 msg(MSG::VERBOSE) << "New RawChannel:"
269 << " ros=" << ros
270 << ", drawer=" << drawer
271 << ", ch=" << channel
272 << ", side=" << side
273 << ", tower=" << tower
274 << ", sample=" << sample
275 << ", pmt=" << pmt
276 << ", e=" << e
277 << ", ie=" << ieta
278 << ", ip=" << iphi;
279
280 if (ieta >= minieta && ieta <= maxieta)
281 msg(MSG::VERBOSE) << endmsg;
282 else
283 msg(MSG::VERBOSE) << " Outside limits" << endmsg;
284 }
285
286 } else {
287 ATH_MSG_VERBOSE( "Tile Channel with no tt_id" );
288 }
289
290 } // end loop over rawChannels in this drawer.
291
292 nTTTot += nTT;
293 nRawChannelTot += nRawChannel;
294 nIgnoreTot += nIgnore;
295
296 ATH_MSG_VERBOSE( "Statistics for"
297 << " ROS=" << ros
298 << ", drawer=" << drawer
299 << "; posneg=" << posneg
300 << ", minieta=" << minieta
301 << ", maxieta=" << maxieta
302 << "; nTT=" << nTT
303 << ", nRawChannel=" << nRawChannel
304 << ", nIgnore=" << nIgnore );
305
306 /*......................................................*/
307 // Step 7: We now have all the TTL1 amplitudes for this drawer.
308 // Loop over towers to produce the electronics signals (= time samples).
309 // If tileNoise is requested, generate random numbers to give noise
310 for (int ieta = minieta; ieta <= maxieta; ++ieta) {
311 int iphi = drawer;
312 bool Good = ttRawChannel[ieta];
313 if (tileNoise)
314 Good = true;
315 if (Good) {
316 if (!ttRawChannel[ieta])
317 ttId[ieta] = m_TT_ID->tower_id(posneg, 1, 0, ieta, drawer);
318
319 ttL1NoiseSigma = m_tileInfo->TTL1NoiseSigma(ttId[ieta]);
320 ttL1Thresh = m_tileInfo->TTL1Thresh(ttId[ieta]);
321 ttL1Ped = m_tileInfo->TTL1Ped(ttId[ieta]);
322 ttL1Calib = m_tileInfo->TTL1Calib(ttId[ieta]);
323 ttAmp[ieta] *= ttL1Calib; // convert pCb to mV
324 if (!m_constantTTL1shape) {
325 // Get phase of the TTL1 tower. default=0,
326 // meaning L1Cal Trigger samples TTL1 pulse right at the peak.
327 // ieta: barrel=0-8, ext.barrel=9-14
328 m_phase = m_tileInfo->ttl1Phase(posneg, ieta, iphi);
329 /* Include shaping fuction, pedestal, and noise. */
331 }
332 if (tileNoise)
333 CLHEP::RandGauss::shootArray(m_nSamp, Rndm);
334 for (int jsamp = 0; jsamp < m_nSamp; ++jsamp) {
335 ttL1samples[jsamp] = ttAmp[ieta] * m_TTL1Shape[jsamp] + ttL1Ped;
336 if (tileNoise)
337 ttL1samples[jsamp] += ttL1NoiseSigma * Rndm[jsamp];
338 } // end loop over samples
339 if (tileThresh) {
340 if (ttL1samples[m_iTrig] - ttL1Ped < ttL1Thresh)
341 Good = false;
342 }
343 } // end first "Good" section.
344 /* Create the new TTL1 object and store in TTL1Container. */
345 if (Good) {
346 ATH_MSG_DEBUG( " TTL1: "
347 << " ros=" << ros
348 << ", ieta=" << ieta
349 << ", iphi=" << iphi
350 << ", rawChannelTrue=" << ttRawChannel[ieta]
351 << ", Good=" << Good
352 << ", amp0=" << ttAmp[ieta]
353 << ", digitIn=" << ttL1samples[m_iTrig] );
354
355 /*
356 The following lines are commented out.
357
358 if (msgLvl(MSG::VERBOSE)) {
359 msg(MSG::VERBOSE) << " ttL1Digits=";
360 for (int jsamp = 0; jsamp < nSamp; ++jsamp) {
361 msg(MSG::VERBOSE) << ttL1samples[jsamp] << " ";
362 }
363 msg(MSG::VERBOSE) << endmsg;
364
365 msg(MSG::VERBOSE) << " Rndm=";
366 for (int jsamp = 0; jsamp < nSamp; ++jsamp) {
367 msg(MSG::VERBOSE) << Rndm[jsamp] << " ";
368 }
369 msg(MSG::VERBOSE) << endmsg;
370 }
371 The preceding lines are commented out
372 */
373
374 ttl1Container->push_back(std::make_unique<TileTTL1>(ttId[ieta], ttL1samples));
375 } // end second "Good" section.
376 } // end loop over towers
377 } // end loop over collections
378
379 // Execution completed.
380 ATH_MSG_DEBUG( "TileRawChannelToTTL1 execution completed." );
381 ATH_MSG_DEBUG( " nTTTot=" << nTTTot
382 << " nRawChannelTot=" << nRawChannelTot
383 << " nIgnoreTot=" << nIgnoreTot
384 << " ttAmpTot=" << ttAmpTot
385 << " ttAmpTotIg=" << ttAmpTotIg
386 << " =>eneTot=" << ttAmpTot + ttAmpTotIg );
387
388 return StatusCode::SUCCESS;
389}
#define endmsg
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_VERBOSE(x,...)
bool msgLvl(const MSG::Level lvl) const
bool is_valid() const
Check if id is in a valid state.
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
@ BARREL_POS
Definition TileHWID.h:68
@ EXTBAR_NEG
Definition TileHWID.h:71
@ BARREL_NEG
Definition TileHWID.h:69
@ EXTBAR_POS
Definition TileHWID.h:70
std::vector< double > m_TTL1Shape
const TileInfo * m_tileInfo
Gaudi::Property< bool > m_constantTTL1shape
const TileHWID * m_tileHWID
SG::WriteHandleKey< TileTTL1Container > m_ttl1ContainerKey
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
main Tile Calibration tool
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
const CaloLVL1_ID * m_TT_ID

◆ 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 TileRawChannelToTTL1::finalize ( )

Definition at line 391 of file TileRawChannelToTTL1.cxx.

391 {
392
393 ATH_MSG_INFO( "TileRawChannelToTTL1::finalize() end" );
394
395 return StatusCode::SUCCESS;
396}
#define ATH_MSG_INFO(x,...)

◆ initialize()

StatusCode TileRawChannelToTTL1::initialize ( )

Definition at line 73 of file TileRawChannelToTTL1.cxx.

73 {
74
75 // retrieve CaloLVL1_ID, TileID, TileHWID helpers and TileIfno from det store
76
77 CHECK( detStore()->retrieve(m_TT_ID) );
78 CHECK( detStore()->retrieve(m_tileID) );
79 CHECK( detStore()->retrieve(m_tileHWID) );
80
81 //=== get TileBadChanTool
82 CHECK( m_tileBadChanTool.retrieve() );
83
84 //=== get TileCondToolEmscale
85 CHECK( m_tileToolEmscale.retrieve() );
86
87 CHECK( detStore()->retrieve(m_tileInfo, m_infoName.value()) );
88
89
90 // Here get already TTL1 Shapes, so as not to perform this on every execute:
91 m_nSamp = m_tileInfo->NdigitSamples(); // number of time slices for each chan
92 m_iTrig = m_tileInfo->ItrigSample(); // index of the triggering time slice
93 m_TTL1Shape.resize(m_nSamp, 0.);
95 m_phase = 0.0;
97 for (int jsamp = 0; jsamp < m_nSamp; ++jsamp) {
98 ATH_MSG_DEBUG( "jsamp=" << jsamp << " ttl1shape=" << m_TTL1Shape[jsamp] );
99 }
100 }
101
102 ATH_CHECK( m_rawChannelContainerKey.initialize() );
103 ATH_CHECK( m_ttl1ContainerKey.initialize() );
104
105 ATH_MSG_INFO( "TileRawChannelToTTL1 initialization completed" );
106
107 return StatusCode::SUCCESS;
108}
#define CHECK(...)
Evaluate an expression and check for errors.
const ServiceHandle< StoreGateSvc > & detStore() const
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Tile Bad Channel tool.
Gaudi::Property< std::string > m_infoName

◆ 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 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ 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_WARNING(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_constantTTL1shape

Gaudi::Property<bool> TileRawChannelToTTL1::m_constantTTL1shape {this, "TileConstantTTL1Shape", true, "Use constant TTL1 shape (phase=0 for all towers)"}
private

Definition at line 78 of file TileRawChannelToTTL1.h.

78{this, "TileConstantTTL1Shape", true, "Use constant TTL1 shape (phase=0 for all towers)"};

◆ 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_infoName

Gaudi::Property<std::string> TileRawChannelToTTL1::m_infoName {this, "TileInfoName", "TileInfo", "Name of TileInfo object in TES"}
private

Definition at line 76 of file TileRawChannelToTTL1.h.

76{this, "TileInfoName", "TileInfo", "Name of TileInfo object in TES"};

◆ m_iTrig

int TileRawChannelToTTL1::m_iTrig {0}
private

Definition at line 88 of file TileRawChannelToTTL1.h.

88{0};

◆ m_nSamp

int TileRawChannelToTTL1::m_nSamp {0}
private

Definition at line 87 of file TileRawChannelToTTL1.h.

87{0};

◆ m_phase

double TileRawChannelToTTL1::m_phase {0}
private

Definition at line 86 of file TileRawChannelToTTL1.h.

86{0};

◆ m_rawChannelContainerKey

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

Definition at line 69 of file TileRawChannelToTTL1.h.

69 {this,"TileRawChannelContainer",
70 "TileRawChannelCnt",
71 "Input Tile raw channel container key"};

◆ m_tileBadChanTool

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

Tile Bad Channel tool.

Definition at line 90 of file TileRawChannelToTTL1.h.

90 {this, "TileBadChanTool",
91 "TileBadChanTool", "Tile bad channel tool"};

◆ m_tileHWID

const TileHWID* TileRawChannelToTTL1::m_tileHWID {nullptr}
private

Definition at line 81 of file TileRawChannelToTTL1.h.

81{nullptr};

◆ m_tileID

const TileID* TileRawChannelToTTL1::m_tileID {nullptr}
private

Definition at line 80 of file TileRawChannelToTTL1.h.

80{nullptr};

◆ m_tileInfo

const TileInfo* TileRawChannelToTTL1::m_tileInfo {nullptr}
private

Definition at line 82 of file TileRawChannelToTTL1.h.

82{nullptr};

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileRawChannelToTTL1::m_tileToolEmscale
private
Initial value:
{this, "TileCondToolEmscale",
"TileCondToolEmscale", "Tile EM scale calibration tool"}

main Tile Calibration tool

Definition at line 92 of file TileRawChannelToTTL1.h.

92 {this, "TileCondToolEmscale",
93 "TileCondToolEmscale", "Tile EM scale calibration tool"};

◆ m_TT_ID

const CaloLVL1_ID* TileRawChannelToTTL1::m_TT_ID {nullptr}
private

Definition at line 83 of file TileRawChannelToTTL1.h.

83{nullptr};

◆ m_ttl1ContainerKey

SG::WriteHandleKey<TileTTL1Container> TileRawChannelToTTL1::m_ttl1ContainerKey
private
Initial value:
{this,"TileTTL1Container",
"TileTTL1Container","Output Tile TTL1 container key"}

Definition at line 73 of file TileRawChannelToTTL1.h.

73 {this,"TileTTL1Container",
74 "TileTTL1Container","Output Tile TTL1 container key"};

◆ m_TTL1Shape

std::vector<double> TileRawChannelToTTL1::m_TTL1Shape
private

Definition at line 85 of file TileRawChannelToTTL1.h.

◆ 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: