#include <LArOFFCRawChannelBuilder.h>

Inheritance diagram for LArOFFCRawChannelBuilder:

Classes
struct	LayerParams
	Resolved parameters for one layer. More...

Public Member Functions
StatusCode	initialize () override
StatusCode	execute (const EventContext &ctx) const override
StatusCode	finalize () 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	buildLayerMap (const EventContext &ctx) const
std::vector< double >	pulseResponse (const ILArShape::ShapeRef_t &shape, const ILArOFC::OFCRef_t &ofc) const
	Filter output for a unit-amplitude pulse, tabulated over every offset of the shape against the OFC window at which the two overlap.
double	computeOFFC (const std::vector< short > &samples, int firstSample, const ILArOFC::OFCRef_t &ofc, const ILArShape::ShapeRef_t &shape, double pedestal, const LayerParams &par) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static size_t	slotOf (int region, int layer)
	Slot for a region code (0=EMB..4=FCAL) and sampling/module; s_nSlots if out of range.
static size_t	slotOfKey (const std::string &key)
	Parse "<REGION>/<LAYER>" into a slot. Returns s_nSlots if unparseable.
static std::string	keyOfSlot (size_t slot)

Private Attributes
SG::ReadHandleKey< LArDigitContainer >	m_digitKey
SG::WriteHandleKey< LArRawChannelContainer >	m_rawChannelKey
SG::ReadCondHandleKey< ILArPedestal >	m_pedestalKey
SG::ReadCondHandleKey< LArADC2MeV >	m_adc2MeVKey
SG::ReadCondHandleKey< ILArOFC >	m_ofcKey
SG::ReadCondHandleKey< ILArShape >	m_shapeKey
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey
SG::ReadCondHandleKey< LArDSPThresholdsComplete >	m_run1DSPThresholdsKey
SG::ReadCondHandleKey< AthenaAttributeList >	m_run2DSPThresholdsKey
Gaudi::Property< float >	m_eCutFortQ
Gaudi::Property< bool >	m_absECutFortQ
Gaudi::Property< bool >	m_useShapeDer
Gaudi::Property< bool >	m_useDBFortQ
Gaudi::Property< int >	m_firstSample
	Index of the digit sample the OFC window starts at, i.e.
Gaudi::Property< double >	m_belowThreshold
	The OFFC extends optimal filtering by finding pulses in the preceding samples and subtracting their expected filter response from the later ones.
Gaudi::Property< int >	m_belowTillReset
	Number of consecutive below-threshold samples after which the pending corrections are dropped, so that stale ones cannot persist through a quiet region.
Gaudi::Property< int >	m_nPulse
	Maximum number of pulse corrections in flight at once.
Gaudi::Property< double >	m_Q3cut
	Quality cut for pulse acceptance.
Gaudi::Property< double >	m_Q3Offset
	Absolute term of the Q3 cut, in ADC.
Gaudi::Property< double >	m_filterThreshold
	Minimum pile-up corrected amplitude required to accept a pulse peak.
Gaudi::Property< std::map< std::string, double > >	m_filterThresholdByLayer
Gaudi::Property< std::map< std::string, double > >	m_q3CutByLayer
Gaudi::Property< std::map< std::string, double > >	m_q3OffsetByLayer
Gaudi::Property< std::map< std::string, int > >	m_nPulseByLayer
Gaudi::Property< std::vector< std::string > >	m_enabledLayers
	Layers the correction may run in; empty means all.
std::vector< LayerParams >	m_layerParams
std::vector< uint8_t > m_slotByHash	ATLAS_THREAD_SAFE
	online hash -> slot, built on the first event: it needs the cabling, which is conditions data with an IOV.
std::once_flag m_slotOnce	ATLAS_THREAD_SAFE
StatusCode m_slotStatus	ATLAS_THREAD_SAFE {StatusCode::SUCCESS}
const LArOnlineID *	m_onlineId = nullptr
const CaloCell_ID *	m_caloId = nullptr
std::atomic< unsigned long >	m_nSubtracted {0}
	Accepted pulses, and those NPulse left no room to subtract.
std::atomic< unsigned long >	m_nDropped {0}
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 size_t	s_nSlots = 20
	Five regions x at most four samplings.

Detailed Description

Definition at line 35 of file LArOFFCRawChannelBuilder.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

◆ buildLayerMap()

StatusCode LArOFFCRawChannelBuilder::buildLayerMap ( const EventContext & ctx ) const

private

Definition at line 82 of file LArOFFCRawChannelBuilder.cxx.

                                   {
  // Layer is an IDENTIFIER quantity, not a geometric one, so this needs no
  // CaloDetDescrManager and has no matching tolerance to get wrong: a
  // channel resolves to exactly one layer or to none.
  const LArOnOffIdMapping* cabling{};
  ATH_CHECK(SG::get(cabling, m_cablingKey, ctx));
 
  const LArEM_ID* emId = m_caloId->em_idHelper();
  const LArHEC_ID* hecId = m_caloId->hec_idHelper();
  const LArFCAL_ID* fcalId = m_caloId->fcal_idHelper();
 
  m_slotByHash.assign(m_onlineId->channelHashMax(),
                      static_cast<uint8_t>(s_nSlots));
  size_t nMapped = 0, nUnmapped = 0;
  for (auto it = m_onlineId->channel_begin(); it != m_onlineId->channel_end();
       ++it) {
    const HWIdentifier hw = *it;
    if (!cabling->isOnlineConnected(hw)) continue;
    const Identifier cid = cabling->cnvToIdentifier(hw);
    int region = -1, layer = -1;
    if (m_caloId->is_em(cid)) {
      region = std::abs(emId->barrel_ec(cid)) - 1;
      layer = emId->sampling(cid);
    } else if (m_caloId->is_hec(cid)) {
      region = 3;
      layer = hecId->sampling(cid);
    } else if (m_caloId->is_fcal(cid)) {
      region = 4;
      layer = fcalId->module(cid);
    } else {
      continue;
    }
    const size_t slot = slotOf(region, layer);
    if (slot >= s_nSlots) { ++nUnmapped; continue; }
    m_slotByHash[m_onlineId->channel_Hash(hw)] = static_cast<uint8_t>(slot);
    ++nMapped;
  }
  ATH_MSG_INFO("layer map: " << nMapped << " channels resolved, " << nUnmapped
                             << " outside the known regions (these fall back "
                                "to the global settings)");
  return StatusCode::SUCCESS;
}

◆ computeOFFC()

double LArOFFCRawChannelBuilder::computeOFFC	(	const std::vector< short > &	samples,
		int	firstSample,
		const ILArOFC::OFCRef_t &	ofc,
		const ILArShape::ShapeRef_t &	shape,
		double	pedestal,
		const LayerParams &	par ) const

private

Definition at line 153 of file LArOFFCRawChannelBuilder.cxx.

                                                                           {
  // OFFC parameters (configured via job options)
  // belowThreshold   : ADC threshold to detect quiet regions
  // belowTillReset   : consecutive quiet samples before cache reset
  // npulse           : max number of overlapping pulses tracked
  // Q3cut            : shape-consistency cut for pulse acceptance
  // filterThreshold  : minimum filtered amplitude to seed a pulse
 
  const int nSamples = samples.size();
  const int ofcLen = ofc.size();
 
  // Checked by the caller. The filter at position i needs samples
  // i ... i+ofcLen-1, and every position it is evaluated at gets a corrected
  // value, so the last one is nSamples-ofcLen.
  if (ofcLen <= 0 || firstSample < 0 || firstSample + ofcLen > nSamples) {
    ATH_MSG_WARNING("Cannot run the OFFC on " << nSamples << " samples with "
                                              << ofcLen << " OFCs from sample "
                                              << firstSample);
    return 0.0;
  }
 
  // Pedestal subtraction
  std::vector<double> samp_no_ped(nSamples);
  for (int i = 0; i < nSamples; ++i)
    samp_no_ped[i] = samples[i] - pedestal;
 
  std::vector<double> reco(nSamples, 0.0);
 
  // Precompute the filter response to a unit-amplitude pulse. cache[lagZero]
  // is the correction of the sample being filtered, cache[lagZero+n] that of
  // the one n later.
  std::vector<double> response = pulseResponse(shape, ofc);
  const int responseSize = response.size();
  if (responseSize == 0) {
    ATH_MSG_WARNING("Empty pulse response, shape size " << shape.size()
                                                        << " OFC size " << ofcLen);
    return 0.0;
  }
 
  // Entry of response[] a pulse is found at. Pulses are identified as local
  // maxima of 'filtered', so the template has to be anchored where the
  // response peaks: that follows whatever alignment the OFCs carry, which is
  // neither fixed nor the same for every channel (see LArOFCCondAlg).
  const int lagZero = anchorIndex(response);
  if (response[lagZero] <= 0.0) {
    ATH_MSG_WARNING("Pulse response is nowhere positive, cannot subtract");
    return 0.0;
  }
 
  // A is the filter output at that peak, so the template must be 1 there. It
  // only already is when the response happens to peak where the OFCs were
  // matched to the shape.
  const double peakResponse = response[lagZero];
  for (double& r : response)
    r /= peakResponse;
  std::vector<double> cache(responseSize, 0.0);
 
  // A pulse writes cache entries lagZero ... responseSize-2, and entry k is
  // consumed k-lagZero iterations later, so that is how long a slot stays busy.
  const int correctionLength = responseSize - 2 - lagZero;
 
  // Sample at which each pulse slot becomes available again
  std::vector<int> slotFreeAt(par.nPulse, 0);
  int belowCounter = 0;
 
  const int loopEnd = std::max(0, nSamples - ofcLen + 1);
 
  for (int i = 0; i < loopEnd; ++i) {
 
    // Reset the correction cache after an extended quiet region
    if (std::abs(samp_no_ped[i]) < par.belowThreshold)
      ++belowCounter;
    else
      belowCounter = 0;
 
    if (par.belowTillReset > 0 && belowCounter >= par.belowTillReset) {
      belowCounter = 0;
      std::fill(cache.begin(), cache.end(), 0.0);
      // The corrections these slots were tracking have just been dropped, so
      // the slots have to be released with them
      std::fill(slotFreeAt.begin(), slotFreeAt.end(), 0);
    }
 
    // Standard OF filtering
    double filtered = 0.0;
    for (int j = 0; j < ofcLen; ++j)
      filtered += samp_no_ped[i + j] * ofc[j];
 
    // Corrected value of the sample just filtered, before anything found this
    // iteration is subtracted from it
    const double recoCurrent = filtered + cache[lagZero];
 
    // Candidate peak: where a pulse would be in time with the OFCs, not where
    // the pulse itself is largest. The search trails the filtering by one, a
    // maximum can only be recognised once the following sample is in.
    const int peak = i - 1;
    if (peak + q3Lags.front() >= 0) {
      const double A = reco.at(peak);
 
      // Local maximum + amplitude cut on the corrected waveform: a pulse
      // riding on the tail of one already subtracted need not be a local
      // maximum of the raw filter output at all.
      if (A > par.filterThreshold && A > reco.at(peak - 1) && A > recoCurrent) {
 
        auto responseVal = [&](int lag) {
          const int k = lagZero + lag;
          return (k >= 0 && k < responseSize) ? response[k] : 0.0;
        };
        // reco[] is final for the peak and everything before it; the sample
        // being filtered is not stored yet, and no later lag can occur here.
        auto recoVal = [&](int lag) {
          return lag <= 0 ? reco.at(peak + lag) : recoCurrent;
        };
 
        double Q3 = 0.0;
        for (int lag : q3Lags)
          Q3 += std::abs(recoVal(lag) - A * responseVal(lag));
 
        // Accept pulse and subtract its forward correction, if NPulse leaves
        // room for it. Shape mismatch scales with the amplitude while the
        // noise floor does not, so the cut carries one term of each: written
        // as a product rather than a ratio to avoid dividing, and A>0 here for
        // any sensible FilterThreshold.
        if (Q3 < par.q3Offset + par.q3Cut * A) {
          const auto slot = std::ranges::find_if(
              slotFreeAt, [i](int freeAt) { return freeAt <= i; });
          if (slot == slotFreeAt.end()) {
            ++m_nDropped;
          } else {
            // The pulse peaks one sample back, so its lag n lands on the entry
            // for sample i+n-1, i.e. cache[lagZero+n-1]
            for (int k = lagZero; k + 1 < responseSize; ++k)
              cache[k] -= response[k + 1] * A;
            *slot = i + correctionLength;
            ++m_nSubtracted;
          }
        }
      }
    }
 
    // Corrected filter output of this sample, now including any pulse just
    // accepted one sample back
    reco[i] = filtered + cache[lagZero];
 
    // Advance correction cache in time
    std::rotate(cache.begin(), cache.begin() + 1, cache.end());
    cache.back() = 0.0;
  }
 
  // Corrected equivalent of the plain OF amplitude, which is the filter output
  // of the window starting at firstSample
  return reco[firstSample];
}

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

95{ return m_detStore; }

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

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

override

Definition at line 454 of file LArOFFCRawChannelBuilder.cxx.

                                                                          {
 
  ATH_MSG_VERBOSE("Executing LArOFFCRawChannelBuilder::execute");
 
  // Get event inputs from read handles:
  const LArDigitContainer* inputContainer{};
  ATH_CHECK(SG::get(inputContainer, m_digitKey, ctx));
 
  // Write output via write handle
  auto outputContainer = std::make_unique<LArRawChannelContainer>();
 
  // Get Conditions input
  const ILArPedestal* peds{};
  ATH_CHECK(SG::get(peds, m_pedestalKey, ctx));
 
  const LArADC2MeV* adc2MeVs{};
  ATH_CHECK(SG::get(adc2MeVs, m_adc2MeVKey, ctx));
 
  const ILArOFC* ofcs{nullptr};
  ATH_CHECK(SG::get(ofcs, m_ofcKey, ctx));
 
  const ILArShape* shapes{};
  ATH_CHECK(SG::get(shapes, m_shapeKey, ctx));
  
  const LArOnOffIdMapping* cabling{};
  ATH_CHECK(SG::get(cabling, m_cablingKey, ctx));
 
  std::unique_ptr<LArDSPThresholdsFlat> run2DSPThresh;
  const LArDSPThresholdsComplete* run1DSPThresh = nullptr;
  ATH_CHECK(SG::get(run1DSPThresh, m_run1DSPThresholdsKey, ctx));
  if (m_useDBFortQ) {
    if (!m_run2DSPThresholdsKey.empty()) {
      SG::ReadCondHandle<AthenaAttributeList> dspThrshAttr(
          m_run2DSPThresholdsKey, ctx);
      run2DSPThresh = std::make_unique<LArDSPThresholdsFlat>(*dspThrshAttr);
      if (!run2DSPThresh->good()) [[unlikely]] {
        ATH_MSG_ERROR(
            "Failed to initialize LArDSPThresholdFlat from attribute list "
            "loaded from "
            << m_run2DSPThresholdsKey.key() << ". Aborting.");
        return StatusCode::FAILURE;
      }
    } else if (!m_run1DSPThresholdsKey.empty()) {
      SG::ReadCondHandle<LArDSPThresholdsComplete> dspThresh(
          m_run1DSPThresholdsKey, ctx);
      run1DSPThresh = dspThresh.cptr();
    } else {
      ATH_MSG_ERROR("No DSP threshold configured.");
      return StatusCode::FAILURE;
    }
  }
 
  // Loop over digits:
  // Built once on the first event, not in initialize(): it needs the
  // cabling, which is conditions data with an IOV.
  std::call_once(m_slotOnce, [&]() {
    m_slotStatus = this->buildLayerMap(ctx);
  });
  ATH_CHECK(m_slotStatus);
 
  for (const LArDigit* digit : *inputContainer) {
 
    const size_t firstSample = m_firstSample;
 
    const HWIdentifier id = digit->hardwareID();
 
    const bool connected = cabling->isOnlineConnected(id);
 
    // Per-layer parameters. The last entry is the global fallback, used for
    // any channel outside the five known regions.
    const IdentifierHash hash = m_onlineId->channel_Hash(id);
    const size_t slot = (hash < m_slotByHash.size())
                            ? static_cast<size_t>(m_slotByHash[hash])
                            : s_nSlots;
    const LayerParams& par = m_layerParams[slot];
 
    const std::vector<short>& samples = digit->samples();
    const int gain = digit->gain();
    const float p = peds->pedestal(id, gain);
 
    // The following autos will resolve either into vectors or vector-proxies
    const auto& ofca = ofcs->OFC_a(id, gain);
    const auto& adc2mev = adc2MeVs->ADC2MEV(id, gain);
    const size_t nOFC = ofca.size();
 
    if (ATH_UNLIKELY(nOFC == 0)) {
      if (!connected)
        continue;  // No conditions for disconencted channel, who cares?
      ATH_MSG_ERROR("No valid OFCs for connected channel "
                    << m_onlineId->channel_name(id) << " gain " << gain);
      return StatusCode::FAILURE;
    }
 
    // Sanity check on input conditions data: ensure the samples vector is
    // compatible with the ofc_a size when preceeding samples are saved.
    // Compared this way round because samples.size()-firstSample would wrap
    // for a short digit.
    if (samples.size() < firstSample + nOFC) {
      ATH_MSG_ERROR("digit has " << samples.size() << " samples, need at least "
                                 << firstSample + nOFC << " for firstSample "
                                 << firstSample << " and OFC_a size " << nOFC);
      return StatusCode::FAILURE;
    }
 
    if (p == ILArPedestal::ERRORCODE) [[unlikely]] {
      if (!connected)
        continue;  // No conditions for disconencted channel, who cares?
      ATH_MSG_ERROR("No valid pedestal for connected channel "
                    << m_onlineId->channel_name(id) << " gain " << gain);
      return StatusCode::FAILURE;
    }
 
    if (adc2mev.size() < 2) [[unlikely]] {
      if (!connected)
        continue;  // No conditions for disconencted channel, who cares?
      ATH_MSG_ERROR("No valid ADC2MeV for connected channel "
                    << m_onlineId->channel_name(id) << " gain " << gain);
      return StatusCode::FAILURE;
    }
 
    // Apply OFFC to get amplitude
    //  Evaluate sums in double-precision to get consistent results
    //  across platforms.
 
    bool saturated = false;
    // Check saturation AND discount pedestal
    std::vector<double> samp_no_ped(nOFC, 0.0);
    for (size_t i = 0; i < nOFC; ++i) {
      if (samples[i + firstSample] == 4096 || samples[i + firstSample] == 0)
        saturated = true;
      samp_no_ped[i] = samples[i + firstSample] - p;
    }
 
    uint16_t iquaShort = 0;
    float tau = 0;
 
    uint16_t prov = LArProv::DEFAULTRECO;  // Means all constants from DB
    if (saturated)
      prov |= LArProv::SATURATED;
 
    float ecut(0.);
    if (m_useDBFortQ) {
      if (run2DSPThresh) {
        ecut = run2DSPThresh->tQThr(id);
      } else if (run1DSPThresh) {
        ecut = run1DSPThresh->tQThr(id);
      } else {
        ATH_MSG_ERROR("DSP threshold problem");
        return StatusCode::FAILURE;
      }
    } else {
      ecut = m_eCutFortQ;
    }
 
    const auto& fullShape = shapes->Shape(id, gain);
 
    double A = computeOFFC(samples, firstSample, ofca, fullShape, p, par);
 
    const float E = adc2mev[0] + A * adc2mev[1];
 
    const float E1 = m_absECutFortQ.value() ? std::fabs(E) : E;
 
    if (E1 > ecut) {
      ATH_MSG_VERBOSE("Channel " << m_onlineId->channel_name(id) << " gain "
                                 << gain
                                 << " above threshold for tQ computation");
      prov |= LArProv::QTPRESENT;  // time+quality information are available
 
      // Get time by applying OFC-b coefficients:
      const auto& ofcb = ofcs->OFC_b(id, gain);
      double At = 0;
      for (size_t i = 0; i < nOFC; ++i) {
        At += static_cast<double>(samp_no_ped[i]) * ofcb[i];
      }
 
      // Divide A*t/A to get time
      tau = (std::fabs(A) > 0.1) ? At / A : 0.0;
 
      // Get Q-factor. The shape has to be offset by the index the OFC window
      // is matched to, which is not the digit offset: the digitisation writes
      // shape index k-nPreceedingSamples into digit sample k. Reading it back
      // from the conditions also covers the HEC shift and the fallback that
      // LArOFCCondAlg applies per channel.
      const std::vector<double> resp = pulseResponse(fullShape, ofca);
      const int shapeShift =
          resp.empty() ? -1 : anchorIndex(resp) - static_cast<int>(nOFC) + 1;
 
      if (shapeShift < 0 || fullShape.size() < nOFC + shapeShift) [[unlikely]] {
        if (!connected)
          continue;  // No conditions for disconnected channel, who cares?
        ATH_MSG_ERROR("No valid shape for channel "
                      << m_onlineId->channel_name(id) << " gain " << gain);
        ATH_MSG_ERROR("Got size " << fullShape.size() << " and offset "
                                  << shapeShift << ", expected at least "
                                  << nOFC << " samples from there");
        return StatusCode::FAILURE;
      }
 
      std::span<const float> shape(fullShape.data() + shapeShift,
                                   fullShape.size() - shapeShift);
 
      double q = 0;
      if (m_useShapeDer) {
        const auto& fullshapeDer = shapes->ShapeDer(id, gain);
        if (fullshapeDer.size() < nOFC + shapeShift) [[unlikely]] {
          ATH_MSG_ERROR("No valid shape derivative for channel "
                        << m_onlineId->channel_name(id) << " gain " << gain);
          ATH_MSG_ERROR("Got size " << fullshapeDer.size()
                                    << ", expected at least "
                                    << nOFC + shapeShift);
          return StatusCode::FAILURE;
        }
 
        std::span<const float> shapeDer(fullshapeDer.data() + shapeShift,
                                        fullshapeDer.size() - shapeShift);
 
        
        for (size_t i = 0; i < nOFC; ++i) {
          q += std::pow((A * (shape[i] - tau * shapeDer[i]) - (samp_no_ped[i])),
                        2);
        }
      }  // end if useShapeDer
      else {
        // Q-factor w/o shape derivative
        for (size_t i = 0; i < nOFC; ++i) {
          q += std::pow((A * shape[i] - (samp_no_ped[i])), 2);
        }
      }
 
      // Clamp before the cast, q can exceed the range of int
      iquaShort = static_cast<uint16_t>(std::min(q, 65535.0));
 
      tau -= ofcs->timeOffset(id, gain);
      tau *= (Gaudi::Units::nanosecond /
              Gaudi::Units::picosecond);  // Convert time to ps
    }  // end if above cut
 
    outputContainer->emplace_back(id, static_cast<int>(std::floor(E + 0.5)),
                                  static_cast<int>(std::floor(tau + 0.5)),
                                  iquaShort, prov, (CaloGain::CaloGain)gain);
  }
 
  SG::WriteHandle<LArRawChannelContainer> outputHandle(m_rawChannelKey, ctx);
  ATH_CHECK(outputHandle.record(std::move(outputContainer)));
 
  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();
}

◆ 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();
  }

◆ finalize()

StatusCode LArOFFCRawChannelBuilder::finalize ( )

override

Definition at line 442 of file LArOFFCRawChannelBuilder.cxx.

                                              {
  const unsigned long dropped = m_nDropped;
  ATH_MSG_INFO("Subtracted " << m_nSubtracted.load() << " pulses, dropped "
                             << dropped << " for want of a free slot (NPulse = "
                             << m_nPulse.value() << ")");
  if (dropped > 0)
    ATH_MSG_WARNING(dropped
                    << " accepted pulses were not subtracted: their correction "
                       "is missing from the output. Raise NPulse to keep them");
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode LArOFFCRawChannelBuilder::initialize ( )

override

Definition at line 312 of file LArOFFCRawChannelBuilder.cxx.

                                                {
  ATH_CHECK(m_digitKey.initialize());
  ATH_CHECK(m_rawChannelKey.initialize());
  ATH_CHECK(m_pedestalKey.initialize());
  ATH_CHECK(m_adc2MeVKey.initialize());
  ATH_CHECK(m_ofcKey.initialize());
  ATH_CHECK(m_shapeKey.initialize());
  ATH_CHECK(m_cablingKey.initialize());
  ATH_CHECK(m_run1DSPThresholdsKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_run2DSPThresholdsKey.initialize(SG::AllowEmpty));
 
  if (m_useDBFortQ) {
    if (m_run1DSPThresholdsKey.empty() && m_run2DSPThresholdsKey.empty()) {
      ATH_MSG_ERROR(
          "useDB requested but neither Run1... nor Run2... initialized.");
      return StatusCode::FAILURE;
    }
  }
 
  ATH_CHECK(detStore()->retrieve(m_onlineId, "LArOnlineID"));
  ATH_CHECK(detStore()->retrieve(m_caloId, "CaloCell_ID"));
 
  // Resolve the per-layer table once. Every slot starts at the global values,
  // so a job that sets no per-layer property behaves exactly as before.
  m_layerParams.assign(s_nSlots + 1,
                       LayerParams{m_Q3cut, m_Q3Offset, m_filterThreshold,
                                   m_nPulse, m_belowThreshold,
                                   m_belowTillReset});
  auto applyD = [&](const std::map<std::string, double>& m, const char* what,
                    double LayerParams::*field) -> StatusCode {
    for (const auto& [key, val] : m) {
      const size_t slot = slotOfKey(key);
      if (slot >= s_nSlots) {
        ATH_MSG_ERROR(what << " has key '" << key
                           << "' which is not <REGION>/<LAYER> with REGION in "
                              "EMB, EMEC-OW, EMEC-IW, HEC, FCAL and LAYER 0-3");
        return StatusCode::FAILURE;
      }
      m_layerParams[slot].*field = val;
    }
    return StatusCode::SUCCESS;
  };
  ATH_CHECK(applyD(m_filterThresholdByLayer, "FilterThresholdByLayer",
                   &LayerParams::filterThreshold));
  ATH_CHECK(applyD(m_q3CutByLayer, "Q3CutByLayer", &LayerParams::q3Cut));
  ATH_CHECK(applyD(m_q3OffsetByLayer, "Q3OffsetByLayer",
                   &LayerParams::q3Offset));
  for (const auto& [key, val] : m_nPulseByLayer) {
    const size_t slot = slotOfKey(key);
    if (slot >= s_nSlots) {
      ATH_MSG_ERROR("NPulseByLayer has unparseable key '" << key << "'");
      return StatusCode::FAILURE;
    }
    if (val < 1) {
      ATH_MSG_ERROR("NPulseByLayer['" << key << "'] is " << val
                                      << ", must be >= 1");
      return StatusCode::FAILURE;
    }
    m_layerParams[slot].nPulse = val;
  }
 
  // Disabling is an unreachable threshold, not a separate branch: no
  // amplitude satisfies A > filterThreshold, so nothing is subtracted and
  // the output is bit-identical to the plain OF (verified to 0 ADC).
  if (!m_enabledLayers.empty()) {
    std::vector<bool> on(s_nSlots + 1, false);
    for (const std::string& key : m_enabledLayers.value()) {
      const size_t slot = slotOfKey(key);
      if (slot >= s_nSlots) {
        ATH_MSG_ERROR("EnabledLayers contains unparseable key '" << key << "'");
        return StatusCode::FAILURE;
      }
      on[slot] = true;
    }
    size_t nOff = 0;
    for (size_t slot = 0; slot <= s_nSlots; ++slot) {
      if (slot < s_nSlots && on[slot]) continue;
      m_layerParams[slot].filterThreshold =
          std::numeric_limits<double>::max();
      ++nOff;
    }
    ATH_MSG_INFO("forward correction enabled in "
                 << m_enabledLayers.size() << " layers; " << nOff
                 << " slots left at the Optimal Filter");
  }
  for (size_t slot = 0; slot < s_nSlots; ++slot) {
    const LayerParams& p = m_layerParams[slot];
    if (p.filterThreshold == std::numeric_limits<double>::max()) continue;
    ATH_MSG_DEBUG(keyOfSlot(slot) << ": Q3Cut=" << p.q3Cut << " Q3Offset="
                                  << p.q3Offset << " FilterThreshold="
                                  << p.filterThreshold << " NPulse="
                                  << p.nPulse);
  }
 
  // The earliest testable candidate peak sits -q3Lags.front() samples into the
  // digit, so anything less leaves no room to find a pulse before the in-time
  // window and the forward correction can never contribute.
  const int minFirstSample = -q3Lags.front() + 1;
  if (m_firstSample < minFirstSample) {
    ATH_MSG_ERROR("firstSample is "
                  << m_firstSample.value() << ", must be >= " << minFirstSample
                  << " for the OFFC to find any pulse before the in-time "
                     "window (set LAr.ROD.nPreceedingSamples accordingly)");
    return StatusCode::FAILURE;
  }
 
  if (m_nPulse < 0) {
    ATH_MSG_ERROR("NPulse is " << m_nPulse.value() << ", must be >= 0");
    return StatusCode::FAILURE;
  }
  if (m_nPulse == 0) {
    ATH_MSG_WARNING(
        "NPulse is 0, no pulse will be subtracted and the OFFC reduces to "
        "plain optimal filtering");
  }
 
  const std::string cutmsg = m_absECutFortQ.value() ? "fabs(E)" : "E";
  if (m_useDBFortQ) {
    ATH_MSG_INFO("Time and quality computed for "
                 << cutmsg << " above the threshold from COOL folder "
                 << m_run1DSPThresholdsKey.key() << " (run1) "
                 << m_run2DSPThresholdsKey.key() << " (run2)");
  } else {
    ATH_MSG_INFO("Time and quality computed for " << cutmsg << " above "
                                                  << m_eCutFortQ.value());
  }
 
  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;
  }

◆ keyOfSlot()

std::string LArOFFCRawChannelBuilder::keyOfSlot ( size_t slot )

staticprivate

Definition at line 76 of file LArOFFCRawChannelBuilder.cxx.

                                                         {
  if (slot >= s_nSlots) return "?";
  return std::string(regionNames[slot / maxLayer]) + "/" +
         std::to_string(slot % maxLayer);
}

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

◆ pulseResponse()

std::vector< double > LArOFFCRawChannelBuilder::pulseResponse	(	const ILArShape::ShapeRef_t &	shape,
		const ILArOFC::OFCRef_t &	ofc ) const

private

Filter output for a unit-amplitude pulse, tabulated over every offset of the shape against the OFC window at which the two overlap.

Entry k is the response for an offset of k-(ofc.size()-1) samples.

Definition at line 126 of file LArOFFCRawChannelBuilder.cxx.

                                                                        {
  // Filter output for a unit-amplitude pulse: same correlation as the
  // filtering loop in computeOFFC, samples replaced by the shape. Writing it
  // as a convolution.
 
  const int shapeSize = shape.size();
  const int ofcSize = ofc.size();
 
  auto shapeVal = [&](int k) {
    return (k >= 0 && k < shapeSize) ? shape[k] : 0.0f;
  };
 
  // response[k] is the filter output for a pulse offset by k-(ofcSize-1)
  // samples from the OFC window, tabulated over the whole range where the two
  // overlap. Where the in-time position falls inside it is up to the OFCs.
  std::vector<double> response(std::max(0, shapeSize + ofcSize - 1), 0.0);
 
  for (int k = 0; k < static_cast<int>(response.size()); ++k) {
    const int offset = k - (ofcSize - 1);
    for (int j = 0; j < ofcSize; ++j)
      response[k] += shapeVal(offset + j) * ofc[j];
  }
 
  return response;
}

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

◆ slotOf()

size_t LArOFFCRawChannelBuilder::slotOf	(	int	region,
		int	layer )

staticprivate

Slot for a region code (0=EMB..4=FCAL) and sampling/module; s_nSlots if out of range.

Definition at line 54 of file LArOFFCRawChannelBuilder.cxx.

                                                             {
  if (region < 0 || region >= static_cast<int>(regionNames.size()))
    return s_nSlots;
  if (layer < 0 || layer >= maxLayer) return s_nSlots;
  return static_cast<size_t>(region) * maxLayer + static_cast<size_t>(layer);
}

◆ slotOfKey()

size_t LArOFFCRawChannelBuilder::slotOfKey ( const std::string & key )

staticprivate

Parse "<REGION>/<LAYER>" into a slot. Returns s_nSlots if unparseable.

Definition at line 61 of file LArOFFCRawChannelBuilder.cxx.

                                                               {
  const auto slash = key.rfind('/');
  if (slash == std::string::npos || slash + 1 >= key.size()) return s_nSlots;
  const std::string region = key.substr(0, slash);
  int layer = -1;
  try {
    layer = std::stoi(key.substr(slash + 1));
  } catch (...) {
    return s_nSlots;
  }
  for (size_t r = 0; r < regionNames.size(); ++r)
    if (region == regionNames[r]) return slotOf(static_cast<int>(r), layer);
  return s_nSlots;
}

◆ 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

◆ ATLAS_THREAD_SAFE [1/3]

StatusCode m_slotStatus LArOFFCRawChannelBuilder::ATLAS_THREAD_SAFE {StatusCode::SUCCESS}

mutableprivate

Definition at line 202 of file LArOFFCRawChannelBuilder.h.

202{StatusCode::SUCCESS};

◆ ATLAS_THREAD_SAFE [2/3]

std::once_flag m_slotOnce LArOFFCRawChannelBuilder::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 201 of file LArOFFCRawChannelBuilder.h.

◆ ATLAS_THREAD_SAFE [3/3]

std::vector<uint8_t> m_slotByHash LArOFFCRawChannelBuilder::ATLAS_THREAD_SAFE

mutableprivate

online hash -> slot, built on the first event: it needs the cabling, which is conditions data with an IOV.

Definition at line 200 of file LArOFFCRawChannelBuilder.h.

◆ m_absECutFortQ

Gaudi::Property<bool> LArOFFCRawChannelBuilder::m_absECutFortQ

private

Initial value:

{

this, "absECut", true, "Cut on fabs(E) for Q and t computation"}

Definition at line 79 of file LArOFFCRawChannelBuilder.h.

79 {

80 this, "absECut", true, "Cut on fabs(E) for Q and t computation"};

◆ m_adc2MeVKey

SG::ReadCondHandleKey<LArADC2MeV> LArOFFCRawChannelBuilder::m_adc2MeVKey

private

Initial value:

{

this, "ADC2MeVKey", "LArADC2MeV", "SG Key of ADC2MeV conditions object"}

Definition at line 58 of file LArOFFCRawChannelBuilder.h.

58 {

59 this, "ADC2MeVKey", "LArADC2MeV", "SG Key of ADC2MeV conditions object"};

◆ m_belowThreshold

Gaudi::Property<double> LArOFFCRawChannelBuilder::m_belowThreshold

private

Initial value:

{
      this, "BelowThreshold", 0,
      "ADC threshold below which samples are treated as noise"}

The OFFC extends optimal filtering by finding pulses in the preceding samples and subtracting their expected filter response from the later ones.

At every position of the pedestal-subtracted digit it applies:

the optimal filter,
a local-maximum pulse search on the corrected filter output,
a shape-consistency (Q3) cut against that same response,
and a forward subtraction of the response of each accepted pulse. ADC threshold below which samples are considered noise. Consecutive samples below this threshold increment a counter used to decide when to reset the forward-subtraction cache.

Definition at line 108 of file LArOFFCRawChannelBuilder.h.

                                        {
      this, "BelowThreshold", 0,
      "ADC threshold below which samples are treated as noise"};

◆ m_belowTillReset

Gaudi::Property<int> LArOFFCRawChannelBuilder::m_belowTillReset

private

Initial value:

{
      this, "BelowTillReset", 0,
      "Number of consecutive noise samples before cache reset (<=0 disables)"}

Number of consecutive below-threshold samples after which the pending corrections are dropped, so that stale ones cannot persist through a quiet region.

Either this or BelowThreshold at zero disables the reset.

Definition at line 115 of file LArOFFCRawChannelBuilder.h.

                                     {
      this, "BelowTillReset", 0,
      "Number of consecutive noise samples before cache reset (<=0 disables)"};

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArOFFCRawChannelBuilder::m_cablingKey

private

Initial value:

{
      this, "CablingKey", "LArOnOffIdMap",
      "SG Key of LArOnOffIdMapping object"}

Definition at line 65 of file LArOFFCRawChannelBuilder.h.

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

◆ m_caloId

const CaloCell_ID* LArOFFCRawChannelBuilder::m_caloId = nullptr

private

Definition at line 207 of file LArOFFCRawChannelBuilder.h.

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

SG::ReadHandleKey<LArDigitContainer> LArOFFCRawChannelBuilder::m_digitKey

private

Initial value:

{

this, "LArDigitKey", "FREE", "SG Key of LArDigitContainer"}

Definition at line 46 of file LArOFFCRawChannelBuilder.h.

46 {

47 this, "LArDigitKey", "FREE", "SG Key of LArDigitContainer"};

◆ m_eCutFortQ

Gaudi::Property<float> LArOFFCRawChannelBuilder::m_eCutFortQ

private

Initial value:

{this, "ECutFortQ", 256.0,
                                     "Time and Quality will be computed only "
                                     "for channels with E above this value"}

Definition at line 76 of file LArOFFCRawChannelBuilder.h.

                                  {this, "ECutFortQ", 256.0,
                                     "Time and Quality will be computed only "
                                     "for channels with E above this value"};

◆ m_enabledLayers

Gaudi::Property<std::vector<std::string> > LArOFFCRawChannelBuilder::m_enabledLayers

private

Initial value:

{
      this, "EnabledLayers", {},
      "Layers where the correction may fire; empty means all"}

Layers the correction may run in; empty means all.

A layer left out gets an unreachable FilterThreshold, so nothing is subtracted and the output is bit-identical to the plain OF – no separate code path.

Definition at line 172 of file LArOFFCRawChannelBuilder.h.

                                                     {
      this, "EnabledLayers", {},
      "Layers where the correction may fire; empty means all"};

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

Gaudi::Property<double> LArOFFCRawChannelBuilder::m_filterThreshold

private

Initial value:

{
      this, "FilterThreshold", 0,
      "Minimum corrected amplitude for pulse finding"}

Minimum pile-up corrected amplitude required to accept a pulse peak.

This suppresses spurious pulse finding due to noise fluctuations.

Definition at line 145 of file LArOFFCRawChannelBuilder.h.

                                         {
      this, "FilterThreshold", 0,
      "Minimum corrected amplitude for pulse finding"};

◆ m_filterThresholdByLayer

Gaudi::Property<std::map<std::string, double> > LArOFFCRawChannelBuilder::m_filterThresholdByLayer

private

Initial value:

{
      this, "FilterThresholdByLayer", {},
      "Per-layer FilterThreshold, keyed <REGION>/<LAYER>; unlisted layers "
      "fall back to FilterThreshold"}

Definition at line 155 of file LArOFFCRawChannelBuilder.h.

                                                                   {
      this, "FilterThresholdByLayer", {},
      "Per-layer FilterThreshold, keyed <REGION>/<LAYER>; unlisted layers "
      "fall back to FilterThreshold"};

◆ m_firstSample

Gaudi::Property<int> LArOFFCRawChannelBuilder::m_firstSample

private

Initial value:

{
      this, "firstSample", 0,
      "Index of the digit sample the OFC window starts at"}

Index of the digit sample the OFC window starts at, i.e.

the amplitude is that of sum_j (samples[firstSample+j]-pedestal)*OFC_a[j]. Not an offset into the reference shape: the digitisation writes shape index k-nPreceedingSamples into digit sample k.

Definition at line 90 of file LArOFFCRawChannelBuilder.h.

                                  {
      this, "firstSample", 0,
      "Index of the digit sample the OFC window starts at"};

◆ m_layerParams

std::vector<LayerParams> LArOFFCRawChannelBuilder::m_layerParams

private

Definition at line 189 of file LArOFFCRawChannelBuilder.h.

◆ m_nDropped

std::atomic<unsigned long> LArOFFCRawChannelBuilder::m_nDropped {0}

mutableprivate

Definition at line 212 of file LArOFFCRawChannelBuilder.h.

212{0};

◆ m_nPulse

Gaudi::Property<int> LArOFFCRawChannelBuilder::m_nPulse

private

Initial value:

{

this, "NPulse", 0, "Maximum number of pulse corrections in flight"}

Maximum number of pulse corrections in flight at once.

A slot is held until the pulse response has been fully subtracted, which for a typical shape outlasts the digit: in practice this caps the pulses per digit.

Definition at line 122 of file LArOFFCRawChannelBuilder.h.

122 {

123 this, "NPulse", 0, "Maximum number of pulse corrections in flight"};

◆ m_nPulseByLayer

Gaudi::Property<std::map<std::string, int> > LArOFFCRawChannelBuilder::m_nPulseByLayer

private

Initial value:

{
      this, "NPulseByLayer", {},
      "Per-layer NPulse; unlisted layers fall back to NPulse"}

Definition at line 165 of file LArOFFCRawChannelBuilder.h.

                                                       {
      this, "NPulseByLayer", {},
      "Per-layer NPulse; unlisted layers fall back to NPulse"};

◆ m_nSubtracted

std::atomic<unsigned long> LArOFFCRawChannelBuilder::m_nSubtracted {0}

mutableprivate

Accepted pulses, and those NPulse left no room to subtract.

Only touched on the rare accepted-pulse branch, summarised in finalize().

Definition at line 211 of file LArOFFCRawChannelBuilder.h.

211{0};

◆ m_ofcKey

SG::ReadCondHandleKey<ILArOFC> LArOFFCRawChannelBuilder::m_ofcKey

private

Initial value:

{this, "OFCKey", "LArOFC",

"SG Key of OFC conditions object"}

Definition at line 60 of file LArOFFCRawChannelBuilder.h.

60 {this, "OFCKey", "LArOFC",

61 "SG Key of OFC conditions object"};

◆ m_onlineId

const LArOnlineID* LArOFFCRawChannelBuilder::m_onlineId = nullptr

private

Definition at line 206 of file LArOFFCRawChannelBuilder.h.

◆ m_pedestalKey

SG::ReadCondHandleKey<ILArPedestal> LArOFFCRawChannelBuilder::m_pedestalKey

private

Initial value:

{
      this, "PedestalKey", "LArPedestal",
      "SG Key of Pedestal conditions object"}

Definition at line 55 of file LArOFFCRawChannelBuilder.h.

                                                 {
      this, "PedestalKey", "LArPedestal",
      "SG Key of Pedestal conditions object"};

◆ m_Q3cut

Gaudi::Property<double> LArOFFCRawChannelBuilder::m_Q3cut

private

Initial value:

{
      this, "Q3Cut", 0.1,
      "Shape-consistency cut for pulse acceptance, on Q3/A"}

Quality cut for pulse acceptance.

Q3 sums the absolute residuals of the corrected filter output against the expected response at lags -2, -1 and +1 from the candidate peak, and is zero for a clean pulse of any amplitude. The cut is applied to Q3/A, so it is a fractional mismatch and does not have to be rescaled with the pulse size. Pulses below it are accepted and subtracted.

Definition at line 131 of file LArOFFCRawChannelBuilder.h.

                               {
      this, "Q3Cut", 0.1,
      "Shape-consistency cut for pulse acceptance, on Q3/A"};

◆ m_q3CutByLayer

Gaudi::Property<std::map<std::string, double> > LArOFFCRawChannelBuilder::m_q3CutByLayer

private

Initial value:

{
      this, "Q3CutByLayer", {},
      "Per-layer Q3Cut; unlisted layers fall back to Q3Cut"}

Definition at line 159 of file LArOFFCRawChannelBuilder.h.

                                                         {
      this, "Q3CutByLayer", {},
      "Per-layer Q3Cut; unlisted layers fall back to Q3Cut"};

◆ m_Q3Offset

Gaudi::Property<double> LArOFFCRawChannelBuilder::m_Q3Offset

private

Initial value:

{
      this, "Q3Offset", 2.0,
      "Absolute term of the Q3 cut in ADC, covering the noise floor"}

Absolute term of the Q3 cut, in ADC.

Q3 has a noise floor of a few times the sample noise whatever the amplitude, so a purely relative cut would reject small pulses on noise alone. Set this comparable to FilterThreshold, the smallest amplitude worth looking at.

Definition at line 139 of file LArOFFCRawChannelBuilder.h.

                                  {
      this, "Q3Offset", 2.0,
      "Absolute term of the Q3 cut in ADC, covering the noise floor"};

◆ m_q3OffsetByLayer

Gaudi::Property<std::map<std::string, double> > LArOFFCRawChannelBuilder::m_q3OffsetByLayer

private

Initial value:

{
      this, "Q3OffsetByLayer", {},
      "Per-layer Q3Offset; unlisted layers fall back to Q3Offset"}

Definition at line 162 of file LArOFFCRawChannelBuilder.h.

                                                            {
      this, "Q3OffsetByLayer", {},
      "Per-layer Q3Offset; unlisted layers fall back to Q3Offset"};

◆ m_rawChannelKey

SG::WriteHandleKey<LArRawChannelContainer> LArOFFCRawChannelBuilder::m_rawChannelKey

private

Initial value:

{
      this, "LArRawChannelKey", "LArRawChannels",
      "SG key of the output LArRawChannelContainer"}

Definition at line 50 of file LArOFFCRawChannelBuilder.h.

                                                          {
      this, "LArRawChannelKey", "LArRawChannels",
      "SG key of the output LArRawChannelContainer"};

◆ m_run1DSPThresholdsKey

SG::ReadCondHandleKey<LArDSPThresholdsComplete> LArOFFCRawChannelBuilder::m_run1DSPThresholdsKey

private

Initial value:

{
      this, "Run1DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 1"}

Definition at line 68 of file LArOFFCRawChannelBuilder.h.

                                                                      {
      this, "Run1DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 1"};

◆ m_run2DSPThresholdsKey

SG::ReadCondHandleKey<AthenaAttributeList> LArOFFCRawChannelBuilder::m_run2DSPThresholdsKey

private

Initial value:

{
      this, "Run2DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 2"}

Definition at line 71 of file LArOFFCRawChannelBuilder.h.

                                                                 {
      this, "Run2DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 2"};

◆ m_shapeKey

SG::ReadCondHandleKey<ILArShape> LArOFFCRawChannelBuilder::m_shapeKey

private

Initial value:

{

this, "ShapeKey", "LArShape", "SG Key of Shape conditions object"}

Definition at line 62 of file LArOFFCRawChannelBuilder.h.

62 {

63 this, "ShapeKey", "LArShape", "SG Key of Shape conditions object"};

◆ m_useDBFortQ

Gaudi::Property<bool> LArOFFCRawChannelBuilder::m_useDBFortQ

private

Initial value:

{this, "useDB", true,

"Use DB for cut on t,Q"}

Definition at line 84 of file LArOFFCRawChannelBuilder.h.

84 {this, "useDB", true,

85 "Use DB for cut on t,Q"};

◆ m_useShapeDer

Gaudi::Property<bool> LArOFFCRawChannelBuilder::m_useShapeDer

private

Initial value:

{
      this, "useShapeDer", true,
      "Use shape derivative in Q-factor computation"}

Definition at line 81 of file LArOFFCRawChannelBuilder.h.

                                   {
      this, "useShapeDer", true,
      "Use shape derivative in Q-factor computation"};

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

size_t LArOFFCRawChannelBuilder::s_nSlots = 20

staticconstexprprivate

Five regions x at most four samplings.

m_layerParams holds s_nSlots+1: the last entry is the global fallback for channels outside those.

Definition at line 188 of file LArOFFCRawChannelBuilder.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Function Documentation

◆ buildLayerMap()

◆ computeOFFC()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ keyOfSlot()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ pulseResponse()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ slotOf()

◆ slotOfKey()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/3]

◆ ATLAS_THREAD_SAFE [2/3]

◆ ATLAS_THREAD_SAFE [3/3]

◆ m_absECutFortQ

◆ m_adc2MeVKey

◆ m_belowThreshold

◆ m_belowTillReset

◆ m_cablingKey

◆ m_caloId

◆ m_detStore

◆ m_digitKey

◆ m_eCutFortQ

◆ m_enabledLayers

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_filterThreshold

◆ m_filterThresholdByLayer

◆ m_firstSample

◆ m_layerParams

◆ m_nDropped

◆ m_nPulse

◆ m_nPulseByLayer

◆ m_nSubtracted

◆ m_ofcKey

◆ m_onlineId

◆ m_pedestalKey

◆ m_Q3cut

◆ m_q3CutByLayer

◆ m_Q3Offset

◆ m_q3OffsetByLayer

◆ m_rawChannelKey

◆ m_run1DSPThresholdsKey

◆ m_run2DSPThresholdsKey

◆ m_shapeKey

◆ m_useDBFortQ

◆ m_useShapeDer

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ s_nSlots