LArRODBCIDCorrAlg Class Reference

Subtract the BCID-dependent pile-up offset from the LArDigit samples. More...

#include <LArRODBCIDCorrAlg.h>

Inheritance diagram for LArRODBCIDCorrAlg:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
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
StatusCode	fillLumi ()
	Fill m_lumi from the beam intensity pattern.
void	computePileupADCCorrection (float mbEnergy, const ILArShape::ShapeRef_t &pulseShape, int bcid, float adc2MeVSlope, float intperBC, bool hecShift, std::vector< float > &pileupADC) const
	Compute the mean pile-up ADC offset per sample for one channel.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< LArDigitContainer >	m_digitKey
SG::WriteHandleKey< LArDigitContainer >	m_digitCorrKey
SG::ReadCondHandleKey< LArADC2MeV >	m_adc2MeVKey
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey
SG::ReadCondHandleKey< ILArShape >	m_shapeKey
SG::ReadCondHandleKey< ILArMinBiasAverage >	m_minBiasAvgKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfo", "EventInfo", "SG key of the EventInfo object" }
Gaudi::Property< std::vector< float > >	m_beamIntensityPattern { this, "BeamIntensityPattern", {}, "LHC beam intensity pattern" }
Gaudi::Property< int >	m_firstSample
Gaudi::Property< int >	m_minBunchCrossing
Gaudi::Property< int >	m_maxBunchCrossing
std::vector< float >	m_lumi
	Per-BCID luminosity, indexed by absolute BCID in [0, s_nBCID).
const LArOnlineID *	m_onlineId = nullptr
	Online identifier helper, used to recognise HEC channels.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr int	s_nBCID = 3564
	Number of bunch crossings in one LHC orbit.

Detailed Description

Subtract the BCID-dependent pile-up offset from the LArDigit samples.

This is the ADC-level equivalent of the energy-level correction performed by CaloBCIDAvgAlg and CaloBCIDCoeffs (Calo.Cell.doPileupOffsetBCIDCorr). The two must not both be enabled, or the offset is subtracted twice.

The sample filling in LArHitEMapToDigitAlg::ConvertHits2Samples is

j = i - ishift + firstSample;  sampleList[i] += Shape[j] * energy

with ishift the bunch crossing of the energy deposit relative to the triggered one, and firstSample the digitisation firstSample (that is, -nPreceedingSamples; see LArDigitizationConfig.py). Averaging over minimum bias events therefore gives, for digit sample i,

ADC_pileup[i] = mbEnergy * mu / adc2MeV
              * sum_j Shape[j] * lumi[(bcid + i + firstSample - j) % 3564]

which for firstSample = 0 is exactly the convolution implemented by CaloBCIDCoeffs. Note that the sample index i and the shape index j enter the luminosity lookup with opposite signs.

Definition at line 51 of file LArRODBCIDCorrAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

computePileupADCCorrection()

void LArRODBCIDCorrAlg::computePileupADCCorrection ( float mbEnergy, const ILArShape::ShapeRef_t & pulseShape, int bcid, float adc2MeVSlope, float intperBC, bool hecShift, std::vector< float > & pileupADC ) const

private

Compute the mean pile-up ADC offset per sample for one channel.

Parameters

	mbEnergy	Average minimum bias energy for this channel, in MeV.
	pulseShape	Pulse shape for this channel and gain.
	bcid	Bunch crossing identifier of the current event.
	adc2MeVSlope	Linear ADC to MeV conversion factor for this gain.
	intperBC	Average number of interactions per bunch crossing.
	hecShift	Whether to apply the one sample shift that LArHitEMapToDigitAlg applies to HEC channels when there are four samples and firstSample is zero.
[out]	pileupADC	Offset per sample. Must be sized to the number of digit samples on entry.

The result is returned through pileupADC rather than by value so that the caller can reuse one buffer across all channels of an event.

Definition at line 268 of file LArRODBCIDCorrAlg.cxx.

{
  const int nShape = static_cast<int> (pulseShape.size());
  const int nSamples = static_cast<int> (pileupADC.size());
  const int firstSample = m_firstSample + (hecShift ? 1 : 0);
 
  for (int i = 0; i < nSamples; ++i) {
    // Digit sample i is fed by a pulse from bunch crossing bc through shape
    // index j, with j = i - bc + firstSample.
    double sum = 0;
    for (int j = 0; j < nShape; ++j) {
      const int bc = i + firstSample - j;
      if (bc < m_minBunchCrossing || bc > m_maxBunchCrossing) {
        continue;
      }
      int idx = (bcid + bc) % s_nBCID;
      if (idx < 0) {
        idx += s_nBCID;
      }
      sum += static_cast<double> (m_lumi[idx]) * pulseShape[j];
    }
    pileupADC[i] =
      static_cast<float> (mbEnergy * sum * intperBC / adc2MeVSlope);
  }
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

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

overridevirtual

Definition at line 71 of file LArRODBCIDCorrAlg.cxx.

{
  ATH_MSG_DEBUG( "Executing LArRODBCIDCorrAlg" );
 
  SG::ReadHandle<LArDigitContainer> digitHandle (m_digitKey, ctx);
  if (!digitHandle.isValid()) {
    ATH_MSG_ERROR( "Failed to retrieve LArDigitContainer "
                   << m_digitKey.key() );
    return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl (m_cablingKey, ctx);
  if (!cablingHdl.isValid()) {
    ATH_MSG_ERROR( "Invalid cabling conditions handle" );
    return StatusCode::FAILURE;
  }
  const LArOnOffIdMapping* cabling = *cablingHdl;
 
  SG::ReadCondHandle<ILArShape> shapesHdl (m_shapeKey, ctx);
  if (!shapesHdl.isValid()) {
    ATH_MSG_ERROR( "Invalid shape conditions handle" );
    return StatusCode::FAILURE;
  }
  const ILArShape* shapes = *shapesHdl;
 
  SG::ReadCondHandle<LArADC2MeV> adc2MeVHdl (m_adc2MeVKey, ctx);
  if (!adc2MeVHdl.isValid()) {
    ATH_MSG_ERROR( "Invalid ADC2MeV conditions handle" );
    return StatusCode::FAILURE;
  }
  const LArADC2MeV* adc2MeVs = *adc2MeVHdl;
 
  SG::ReadCondHandle<ILArMinBiasAverage> minBiasAvgHdl (m_minBiasAvgKey, ctx);
  if (!minBiasAvgHdl.isValid()) {
    ATH_MSG_ERROR( "Invalid MinBiasAverage conditions handle" );
    return StatusCode::FAILURE;
  }
  const ILArMinBiasAverage* minBiasAvg = minBiasAvgHdl.cptr();
 
  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
  if (!eventInfo.isValid()) {
    ATH_MSG_ERROR( "Failed to retrieve EventInfo" );
    return StatusCode::FAILURE;
  }
 
  const int bcid = static_cast<int> (eventInfo->bcid());
  if (bcid < 0 || bcid >= s_nBCID) {
    ATH_MSG_ERROR( "BCID " << bcid << " is outside [0, " << s_nBCID << ")" );
    return StatusCode::FAILURE;
  }
  const float intperBC = eventInfo->averageInteractionsPerCrossing();
 
  SG::WriteHandle<LArDigitContainer> outHandle (m_digitCorrKey, ctx);
  auto output = std::make_unique<LArDigitContainer> (SG::OWN_ELEMENTS);
  LArDigitContainer* outputPtr = output.get();
  outputPtr->reserve (digitHandle->size());
  ATH_CHECK( outHandle.record (std::move (output)) );
 
  // Declared outside the loop so that the buffers are reused across channels.
  std::vector<float> pileupADC;
  std::vector<short> correctedSamples;
  size_t nClamped = 0;
 
  for (const LArDigit* digit : *digitHandle) {
 
    const HWIdentifier id = digit->hardwareID();
    const CaloGain::CaloGain gain = digit->gain();
    const std::vector<short>& rawSamples = digit->samples();
 
    float slope = 0;
    float mbEnergy = 0;
    ILArShape::ShapeRef_t pulseShape;
    bool correctable = cabling->isOnlineConnected (id) && !rawSamples.empty();
    if (correctable) {
      const auto& adc2mev = adc2MeVs->ADC2MEV (id, gain);
      correctable = adc2mev.size() >= 2 &&
                    std::abs (adc2mev[1]) > minAdc2MeVSlope;
      if (correctable) {
        slope = adc2mev[1];
        pulseShape = shapes->Shape (id, gain);
        correctable = !pulseShape.empty();
      }
      if (correctable) {
        // A non-positive average means no correction, as in CaloBCIDCoeffs.
        // This also catches ILArMinBiasAverage::ERRORCODE.
        mbEnergy = minBiasAvg->minBiasAverage (id);
        correctable = mbEnergy > 0;
      }
    }
 
    // Channels for which no correction can be computed are copied through
    // unchanged, so that the output container always mirrors the input.
    if (!correctable) {
      outputPtr->push_back (std::make_unique<LArDigit> (id, gain, rawSamples));
      continue;
    }
 
    // LArHitEMapToDigitAlg shifts the HEC shape by one sample in the four
    // sample readout, so reproduce that here to stay aligned with the digits.
    const bool hecShift = rawSamples.size() == hecShiftNSamples &&
                          m_firstSample == 0 &&
                          m_onlineId->isHECchannel (id);
 
    pileupADC.assign (rawSamples.size(), 0);
    computePileupADCCorrection (mbEnergy, pulseShape,
                                 bcid, slope, intperBC, hecShift, pileupADC);
 
    // The corrected value is clamped to the range of short rather than to the
    // ADC range -> the raw channel builders treat samples of 0 and 4096 as
    // saturation markers, so clipping there would flag saturation spuriously.
 
    correctedSamples.resize (rawSamples.size());
    for (size_t i = 0; i < rawSamples.size(); ++i) {
      const long corrected =
        std::lround (static_cast<double> (rawSamples[i]) -
                     static_cast<double> (pileupADC[i]));
      const long clamped =
        std::clamp (corrected,
                    static_cast<long> (std::numeric_limits<short>::lowest()),
                    static_cast<long> (std::numeric_limits<short>::max()));
      if (clamped != corrected) {
        ++nClamped;
      }
      correctedSamples[i] = static_cast<short> (clamped);
    }
 
    outputPtr->push_back
      (std::make_unique<LArDigit> (id, gain, correctedSamples));
  }
 
  if (nClamped > 0) {
    ATH_MSG_WARNING( nClamped << " corrected sample(s) fell outside the range "
                     "of short and were clamped" );
  }
 
  ATH_MSG_DEBUG( "Wrote " << outputPtr->size() << " digits to "
                 << m_digitCorrKey.key() );
 
  return StatusCode::SUCCESS;
}

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.

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

fillLumi()

StatusCode LArRODBCIDCorrAlg::fillLumi ( )

private

Fill m_lumi from the beam intensity pattern.

Uses the same pattern-to-BCID mapping as BunchCrossingCondAlg, so that the set of filled bunch crossings matches the one CaloBCIDLumi would see.

Definition at line 212 of file LArRODBCIDCorrAlg.cxx.

{
  const std::vector<float>& pattern = m_beamIntensityPattern;
  if (pattern.empty()) {
    ATH_MSG_ERROR( "BeamIntensityPattern is empty. It must be set from "
                   "flags.Digitization.PU.BeamIntensityPattern." );
    return StatusCode::FAILURE;
  }
 
  const int nPattern = static_cast<int> (pattern.size());
  m_lumi.assign (s_nBCID, 0);
 
  // Reproduce BunchCrossingCondAlg, so that the set of filled bunch crossings
  // used here is identical to the one in BunchCrossingCondData, which is what
  // the energy level correction uses.
  if (s_nBCID % nPattern != 0) {
    ATH_MSG_INFO( "Bunch pattern of length " << nPattern
                  << " does not fit into " << s_nBCID );
    // As in BunchCrossingCondAlg, the loop deliberately stops short of the
    // half orbit so as not to produce an odd pattern half way round.
    const int nGuard = 20;
    for (int i = 0; i < s_nBCID / 2 - nGuard; ++i) {
      const int pos1 = i % nPattern;
      const int pos2 = nPattern - 1 - (i % nPattern);
      if (pattern[pos1] > minBunchIntensity) {
        m_lumi[i] = xlumiMC;
      }
      if (pattern[pos2] > minBunchIntensity) {
        m_lumi[s_nBCID - 1 - i] = xlumiMC;
      }
    }
  }
  else {
    ATH_MSG_INFO( "Bunch pattern of length " << nPattern << " fits into "
                  << s_nBCID );
    for (int i = 0; i < s_nBCID; ++i) {
      if (pattern[i % nPattern] > minBunchIntensity) {
        m_lumi[i] = xlumiMC;
      }
    }
  }
 
  const int nFilled = std::count_if (m_lumi.begin(), m_lumi.end(),
                                     [] (float lumi) { return lumi > 0; });
  ATH_MSG_INFO( "Filled " << nFilled << " of " << s_nBCID
                << " bunch crossings" );
  if (nFilled == 0) {
    ATH_MSG_ERROR( "No filled bunch crossing found in the beam intensity "
                   "pattern, so the correction would be identically zero." );
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

filterPassed()

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

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

initialize()

StatusCode LArRODBCIDCorrAlg::initialize ( )

overridevirtual

Definition at line 43 of file LArRODBCIDCorrAlg.cxx.

{
  ATH_CHECK( m_digitKey.initialize() );
  ATH_CHECK( m_digitCorrKey.initialize() );
  ATH_CHECK( m_adc2MeVKey.initialize() );
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_shapeKey.initialize() );
  ATH_CHECK( m_minBiasAvgKey.initialize() );
  ATH_CHECK( m_eventInfoKey.initialize() );
 
  ATH_CHECK( detStore()->retrieve (m_onlineId, "LArOnlineID") );
 
  if (m_minBunchCrossing > m_maxBunchCrossing) {
    ATH_MSG_ERROR( "MinBunchCrossing (" << m_minBunchCrossing
                   << ") is larger than MaxBunchCrossing ("
                   << m_maxBunchCrossing << ")" );
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK( fillLumi() );
 
  ATH_MSG_INFO( "firstSample = " << m_firstSample
                << ", so digit sample 0 corresponds to bunch crossing "
                << m_firstSample << " relative to the triggered one" );
 
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isClonable()

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.

                                           {
    return true;
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

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

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.

{
  return BaseAlg::sysExecute (ctx);
}

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, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_adc2MeVKey

SG::ReadCondHandleKey<LArADC2MeV> LArRODBCIDCorrAlg::m_adc2MeVKey

private

Initial value:

{ this, "ADC2MeVKey", "LArADC2MeV",
    "SG key of the ADC2MeV conditions object" }

Definition at line 71 of file LArRODBCIDCorrAlg.h.

  { this, "ADC2MeVKey", "LArADC2MeV",
    "SG key of the ADC2MeV conditions object" };

m_beamIntensityPattern

Gaudi::Property<std::vector<float> > LArRODBCIDCorrAlg::m_beamIntensityPattern { this, "BeamIntensityPattern", {}, "LHC beam intensity pattern" }

private

Definition at line 90 of file LArRODBCIDCorrAlg.h.

{ this, "BeamIntensityPattern", {}, "LHC beam intensity pattern" };

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArRODBCIDCorrAlg::m_cablingKey

private

Initial value:

{ this, "CablingKey", "LArOnOffIdMap",
    "SG key of the LArOnOffIdMapping object" }

Definition at line 75 of file LArRODBCIDCorrAlg.h.

  { this, "CablingKey", "LArOnOffIdMap",
    "SG key of the LArOnOffIdMapping object" };

m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_digitCorrKey

SG::WriteHandleKey<LArDigitContainer> LArRODBCIDCorrAlg::m_digitCorrKey

private

Initial value:

{ this, "OutputDigitKey", "LArDigitContainer_PileupCorrected",
    "SG key of the output LArDigitContainer" }

Definition at line 67 of file LArRODBCIDCorrAlg.h.

  { this, "OutputDigitKey", "LArDigitContainer_PileupCorrected",
    "SG key of the output LArDigitContainer" };

m_digitKey

SG::ReadHandleKey<LArDigitContainer> LArRODBCIDCorrAlg::m_digitKey

private

Initial value:

{ this, "LArDigitKey", "LArDigitContainer_MC",
    "SG key of the input LArDigitContainer" }

Definition at line 63 of file LArRODBCIDCorrAlg.h.

  { this, "LArDigitKey", "LArDigitContainer_MC",
    "SG key of the input LArDigitContainer" };

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> LArRODBCIDCorrAlg::m_eventInfoKey { this, "EventInfo", "EventInfo", "SG key of the EventInfo object" }

private

Definition at line 87 of file LArRODBCIDCorrAlg.h.

{ this, "EventInfo", "EventInfo", "SG key of the EventInfo object" };

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl 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_firstSample

Gaudi::Property<int> LArRODBCIDCorrAlg::m_firstSample

private

Initial value:

{ this, "firstSample", 0,
    "Digitisation firstSample: the shape index seen by digit sample 0. Must be "
    "set exactly as LArHitEMapToDigitAlg.firstSample, that is "
    "-nPreceedingSamples, or LAr.ROD.FirstSample when that is zero." }

Definition at line 93 of file LArRODBCIDCorrAlg.h.

  { this, "firstSample", 0,
    "Digitisation firstSample: the shape index seen by digit sample 0. Must be "
    "set exactly as LArHitEMapToDigitAlg.firstSample, that is "
    "-nPreceedingSamples, or LAr.ROD.FirstSample when that is zero." };

m_lumi

std::vector<float> LArRODBCIDCorrAlg::m_lumi

private

Per-BCID luminosity, indexed by absolute BCID in [0, s_nBCID).

Filled once in initialize() and only read afterwards, so it is safe to share between threads.

Definition at line 113 of file LArRODBCIDCorrAlg.h.

m_maxBunchCrossing

Gaudi::Property<int> LArRODBCIDCorrAlg::m_maxBunchCrossing

private

Initial value:

{ this, "MaxBunchCrossing", s_nBCID,
    "Latest bunch crossing, relative to the triggered one, included in the "
    "correction." }

Definition at line 105 of file LArRODBCIDCorrAlg.h.

  { this, "MaxBunchCrossing", s_nBCID,
    "Latest bunch crossing, relative to the triggered one, included in the "
    "correction." };

m_minBiasAvgKey

SG::ReadCondHandleKey<ILArMinBiasAverage> LArRODBCIDCorrAlg::m_minBiasAvgKey

private

Initial value:

{ this, "MinBiasAvgKey", "LArPileupAverageSym",
    "SG key of the LArMinBiasAverage object" }

Definition at line 83 of file LArRODBCIDCorrAlg.h.

  { this, "MinBiasAvgKey", "LArPileupAverageSym",
    "SG key of the LArMinBiasAverage object" };

m_minBunchCrossing

Gaudi::Property<int> LArRODBCIDCorrAlg::m_minBunchCrossing

private

Initial value:

{ this, "MinBunchCrossing", -s_nBCID,
    "Earliest bunch crossing, relative to the triggered one, included in the "
    "correction. Set this to the earliest crossing actually overlaid by the "
    "digitisation to avoid over-subtracting in the preceding samples." }

Definition at line 99 of file LArRODBCIDCorrAlg.h.

  { this, "MinBunchCrossing", -s_nBCID,
    "Earliest bunch crossing, relative to the triggered one, included in the "
    "correction. Set this to the earliest crossing actually overlaid by the "
    "digitisation to avoid over-subtracting in the preceding samples." };

m_onlineId

const LArOnlineID* LArRODBCIDCorrAlg::m_onlineId = nullptr

private

Online identifier helper, used to recognise HEC channels.

Definition at line 116 of file LArRODBCIDCorrAlg.h.

m_shapeKey

SG::ReadCondHandleKey<ILArShape> LArRODBCIDCorrAlg::m_shapeKey

private

Initial value:

{ this, "ShapeKey", "LArShape",
    "SG key of the LArShape conditions object" }

Definition at line 79 of file LArRODBCIDCorrAlg.h.

  { this, "ShapeKey", "LArShape",
    "SG key of the LArShape conditions object" };

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_nBCID

int LArRODBCIDCorrAlg::s_nBCID = 3564

staticconstexprprivate

Number of bunch crossings in one LHC orbit.

Definition at line 61 of file LArRODBCIDCorrAlg.h.

---

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

• LArRODBCIDCorrAlg.h
• LArRODBCIDCorrAlg.cxx