TileDigitsMaker Class Reference

This algorithm performs digitization in TileCal, obtaining TileDigits from TileHits. More...

#include <TileDigitsMaker.h>

Inheritance diagram for TileDigitsMaker:

Public Member Functions
virtual	~TileDigitsMaker ()=default
virtual StatusCode	initialize () override
	initialize method
virtual StatusCode	execute (const EventContext &ctx) const override
	execute method
virtual StatusCode	finalize () override
	finalize method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	overlayBackgroundDigits (const TileDigitsCollection *bkgDigitCollection, const TileHitCollection *hitCollection, std::vector< std::vector< double > > &drawerBufferLo, std::vector< std::vector< double > > &drawerBufferHi, std::vector< int > &igain, int ros, int drawer, int drawerIdx, std::vector< int > &over_gain, const TileEMScale *emScale, const TileSampleNoise *sampleNoise, const TileDQstatus *dqStatus, const TileBadChannels *badChannels) const
StatusCode	fillDigitCollection (const TileHitCollection *hitCollection, std::vector< std::vector< double > > &drawerBufferLo, std::vector< std::vector< double > > &drawerBufferHi, std::vector< int > &igain, std::vector< int > &overgain, std::vector< double > &ech_int, std::vector< bool > &signal_in_channel, const TileEMScale *emScale, const TileSamplingFraction *samplingFraction, const TilePulse *pulse) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< TileHitContainer >	m_hitContainerKey
SG::ReadHandleKey< TileHitContainer >	m_hitContainer_DigiHSTruthKey
Gaudi::Property< bool >	m_onlyUseContainerName
SG::ReadHandleKey< TileDigitsContainer >	m_inputDigitContainerKey {this, "InputTileDigitContainer","",""}
std::string	m_inputDigitContainerName {""}
SG::WriteHandleKey< TileDigitsContainer >	m_digitsContainerKey
SG::WriteHandleKey< TileDigitsContainer >	m_digitsContainer_DigiHSTruthKey
SG::WriteHandleKey< TileDigitsContainer >	m_filteredDigitsContainerKey
Gaudi::Property< double >	m_filterThreshold
Gaudi::Property< double >	m_filterThresholdMBTS
Gaudi::Property< std::string >	m_infoName
Gaudi::Property< bool >	m_integerDigits
Gaudi::Property< bool >	m_calibRun
Gaudi::Property< bool >	m_rndmEvtOverlay
Gaudi::Property< bool >	m_useCoolPulseShapes
Gaudi::Property< bool >	m_maskBadChannels
Gaudi::Property< bool >	m_doDigiTruth
Gaudi::Property< int >	m_allChannels
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc"}
const TileID *	m_tileID {nullptr}
const TileTBID *	m_tileTBID {nullptr}
const TileHWID *	m_tileHWID {nullptr}
const TileInfo *	m_tileInfo {nullptr}
const TileCablingService *	m_cabling {nullptr}
	TileCabling instance.
std::vector< std::unique_ptr< HWIdentifier[]> >	m_all_ids
int	m_nSamples {0}
	Number of time slices for each channel.
int	m_iTrig {0}
	Index of the triggering time slice.
int	m_i_ADCmax {0}
	ADC saturation value.
float	m_f_ADCmax {0.0F}
	ADC saturation value.
float	m_f_ADCmaxHG {0.0F}
	ADC saturation value - 0.5.
float	m_ADCmaxMinusEps {0.0F}
	ADC saturation value - 0.01 or something small.
float	m_ADCmaxPlusEps {0.0F}
	ADC saturation value + 0.01 or something small.
float	m_f_ADCmaskValue {0.0F}
	indicates channels which were masked in background dataset
bool	m_tileNoise {false}
	If true => generate noise in TileDigits.
bool	m_tileCoherNoise {false}
	If true => generate coherent noise in TileDigits.
bool	m_tileThresh {false}
	If true => apply threshold to Digits.
double	m_tileThreshHi {0.0}
	Actual threshold value for high gain.
double	m_tileThreshLo {0.0}
	Actual threshold value for low gain.
std::vector< double >	m_digitShapeHi
	High gain pulse shape.
int	m_nShapeHi {0}
	Number of bins in high gain pulse shape.
int	m_nBinsPerXHi {0}
	Number of bins per bunch crossing in high gain pulse shape.
int	m_binTime0Hi {0}
	Index of time=0 bin for high gain pulse shape.
double	m_timeStepHi {0.}
	Time step in high gain pulse shape: 25.0 / nBinsPerXHi.
std::vector< double >	m_digitShapeLo
	Low gain pulse shape.
int	m_nShapeLo {0}
	Number of bins in low gain pulse shape.
int	m_nBinsPerXLo {0}
	Number of bins per bunch crossing in low gain pulse shape.
int	m_binTime0Lo {0}
	Index of time=0 bin for low gain pulse shape.
double	m_timeStepLo {0.}
	Time step in low gain pulse shape: 25.0 / nBinsPerXLo.
ServiceHandle< TileCablingSvc >	m_cablingSvc
	Name of Tile cabling service.
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service to use.
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Tile_DigitsMaker", ""}
	Random Stream Name.
SG::ReadCondHandleKey< TileSampleNoise >	m_sampleNoiseKey
	Name of TileSampleNoise in condition store.
SG::ReadCondHandleKey< TileEMScale >	m_emScaleKey
	Name of TileEMScale in condition store.
SG::ReadCondHandleKey< TilePulse >	m_pulseShapeKey
	Name of TilePulseShape in condition store.
SG::ReadCondHandleKey< TileSamplingFraction >	m_samplingFractionKey
	Name of TileSamplingFraction in condition store.
SG::ReadCondHandleKey< TileBadChannels >	m_badChannelsKey
	Name of TileBadChannels in condition store.
SG::ReadHandleKey< TileDQstatus >	m_DQstatusKey
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This algorithm performs digitization in TileCal, obtaining TileDigits from TileHits.

Hits from the PMTs in the cell are merged and calibration constants applied to obtained cell energy, time and quality. Starting from hits, pulse shapes are applied and the resulting pulses are digitized. Depending on the options selected, electronic noise and photoelectron statistical fluctuations are simulated in this procedure.

Definition at line 79 of file TileDigitsMaker.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~TileDigitsMaker()

virtual TileDigitsMaker::~TileDigitsMaker ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

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

overridevirtual

execute method

Definition at line 262 of file TileDigitsMaker.cxx.

                                                                 {
  ATH_MSG_DEBUG( "Executing TileDigitsMaker");
 
  // Prepare RNG service
  ATHRNG::RNGWrapper* rngWrapper = nullptr;
  CLHEP::HepRandomEngine* rngEngine = nullptr;
  if (m_tileNoise || m_tileCoherNoise || m_rndmEvtOverlay) {
    rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
    rngWrapper->setSeed( m_randomStreamName, ctx );
    rngEngine = rngWrapper->getEngine(ctx);
  }
 
  SG::ReadCondHandle<TileSampleNoise> sampleNoise(m_sampleNoiseKey, ctx);
  ATH_CHECK( sampleNoise.isValid() );
 
  bool first = (msgLvl(MSG::VERBOSE) && ctx.evt() == 0 && !m_rndmEvtOverlay );
  if (first) {
    ATH_MSG_VERBOSE( "Dumping 2G noise parameters");
    first = false;
    IdContext drawer_context = m_tileHWID->drawer_context();
    int ndrawers = m_tileHWID->drawer_hash_max();
    const int nchMax = 48; // number of channels per drawer
    for (int dr = 0; dr < ndrawers; ++dr) {
      HWIdentifier drawer_id;
      m_tileHWID->get_id(dr, drawer_id, &drawer_context);
      int ros = m_tileHWID->ros(drawer_id);
      int drawer = m_tileHWID->drawer(drawer_id);
      if (m_cabling->connected(ros, drawer)) {
        IdentifierHash idhash;
        m_tileHWID->get_hash(drawer_id, idhash, &drawer_context);
        for (int ch = 0; ch < nchMax; ++ch) {
          double pedSimHi = sampleNoise->getPed(idhash, ch, TileID::HIGHGAIN);
          double sigmaHi_Hfn1 = sampleNoise->getHfn1(idhash, ch, TileID::HIGHGAIN);
          double sigmaHi_Hfn2 = sampleNoise->getHfn2(idhash, ch, TileID::HIGHGAIN);
          double sigmaHi_Norm = sampleNoise->getHfnNorm(idhash, ch, TileID::HIGHGAIN);
          double pedSimLo = sampleNoise->getPed(idhash, ch, TileID::LOWGAIN);
          double sigmaLo_Hfn1 = sampleNoise->getHfn1(idhash, ch, TileID::LOWGAIN);
          double sigmaLo_Hfn2 = sampleNoise->getHfn2(idhash, ch, TileID::LOWGAIN);
          double sigmaLo_Norm = sampleNoise->getHfnNorm(idhash, ch, TileID::LOWGAIN);
          ATH_MSG_VERBOSE( "Channel " << m_tileHWID->to_string(drawer_id,-2) << "/" << ch
                           << " pedHi="<< pedSimHi
                           << " pedLo="<< pedSimLo
                           << " rmsHi="<< sigmaHi_Hfn1 << "," << sigmaHi_Hfn2 << "," << sigmaHi_Norm
                           << " rmsLo="<< sigmaLo_Hfn1 << "," << sigmaLo_Hfn2 << "," << sigmaLo_Norm);
 
        }
      }
    }
  }
 
  // declare array for random number generation
  double Rndm[16];       // Can't use variable size array,
  double RndmLo[16];     // Can't use variable size array,
  double Rndm_dG[1];    // uniform random number for the double gaussian
  double RndmLo_dG[1];  // uniform random number for the double gaussian
 
  // step1: Get hit container from TES 
  SG::ReadHandle<TileHitContainer> hitContainer(m_hitContainerKey, ctx);
  ATH_CHECK( hitContainer.isValid() );
 
  SG::ReadHandle<TileHitContainer> hitContainer_DigiHSTruth;
  if(m_doDigiTruth){
      hitContainer_DigiHSTruth = SG::ReadHandle<TileHitContainer> (m_hitContainer_DigiHSTruthKey, ctx);
      ATH_CHECK( hitContainer_DigiHSTruth.isValid() );
  }
 
  // Zero sums for monitoring.
  int nChSum = 0;
  int nChHiSum = 0;
  int nChLoSum = 0;
  int nChHiAcc = 0;
  int nChLoAcc = 0;
  int nChHiFlt = 0;
  int nChLoFlt = 0;
  int nChHiCut = 0;
  int nChLoCut = 0;
  double echtot_Acc = 0.;
  double echint_Acc = 0.;
  double echtot_Cut = 0.;
  double echint_Cut = 0.;
  double HitSum = 0.;
  double EneSum = 0.;
  double RChSum = 0.;
 
  /* step2: Set up  Digits container */
 
  auto digitsContainer = std::make_unique<TileMutableDigitsContainer>(true,
                                                                      TileFragHash::Digitizer,
                                                                      TileRawChannelUnit::ADCcounts);
  ATH_CHECK( digitsContainer->status() );
 
  std::unique_ptr<TileMutableDigitsContainer> digitsContainer_DigiHSTruth;
  if(m_doDigiTruth){
    digitsContainer_DigiHSTruth = std::make_unique<TileMutableDigitsContainer>(true,
                                                                               TileFragHash::Digitizer,
                                                                               TileRawChannelUnit::ADCcounts);
    ATH_CHECK( digitsContainer_DigiHSTruth->status() );
  }
 
  std::unique_ptr<TileMutableDigitsContainer> filteredContainer;
  if (!m_filteredDigitsContainerKey.key().empty()) {
    filteredContainer = std::make_unique<TileMutableDigitsContainer>(true,
                                                                     TileFragHash::Digitizer,
                                                                     TileRawChannelUnit::ADCcounts,
                                                                     SG::VIEW_ELEMENTS);
    ATH_CHECK( filteredContainer->status() );
  }
 
  /* Set up buffers for handling information in a single collection. */
  IdentifierHash idhash;
  IdContext drawer_context = m_tileHWID->drawer_context();
  const int nchMax = 48; // number of channels per drawer
  std::vector<int> igain(nchMax, -1);
  std::vector<int> ntot_ch(nchMax, 0);
  std::vector<double> ech_tot(nchMax, 0.0);
  std::vector<double> ech_int(nchMax, 0);
  std::vector<double> ech_int_DigiHSTruth(nchMax, 0);
  std::vector<int> over_gain(nchMax, -1);
 
  /* Make a vector of digits (to be filled at the end from m_drawerBuffer arrays) */
  std::vector<float> digitsBuffer(m_nSamples);
  std::vector<float> digitsBufferLo(m_nSamples); // for calib runs
  std::vector<float> digitsBuffer_DigiHSTruth(m_nSamples);
  std::vector<float> digitsBufferLo_DigiHSTruth(m_nSamples); // for calib runs
 
  std::vector<double> emptyBuffer;
  std::vector<std::vector<double>> drawerBufferHi(nchMax, std::vector<double>(m_nSamples));
  std::vector<std::vector<double>> drawerBufferLo(nchMax, std::vector<double>(m_nSamples));
 
  std::vector<std::vector<double>> drawerBufferHi_DigiHSTruth;
  std::vector<std::vector<double>> drawerBufferLo_DigiHSTruth;
  if (m_doDigiTruth) {
    drawerBufferHi_DigiHSTruth.resize(nchMax, std::vector<double>(m_nSamples));
    drawerBufferLo_DigiHSTruth.resize(nchMax, std::vector<double>(m_nSamples));
  }
 
 
  /* everything for calculation of coherent noise */
  // booleans for coherent noise
  Bool_t coherNoiseHi = false;
  Bool_t coherNoiseLo = false;
  TMatrixD CorrWeightHi;
  TMatrixD CorrWeightLo;
  std::vector<std::unique_ptr<double[]>> CorrRndmVec;
  std::vector<std::unique_ptr<double[]>> CorrRndmVecLo;
  if (m_tileCoherNoise) {
    for (int k = 0; k < m_nSamples; ++k) {
      CorrRndmVec.push_back(std::make_unique<double[]>(nchMax));
    }
    if (m_calibRun) {
      for (int k = 0; k < m_nSamples; ++k) {
        CorrRndmVecLo.push_back(std::make_unique<double[]>(nchMax));
      }
    }
  }
 
  TileMutableDigitsContainer::const_iterator collItrRndm;
  TileMutableDigitsContainer::const_iterator lastCollRndm;
  std::unique_ptr<TileMutableDigitsContainer> backgroundDigitContainer{};
  if (m_rndmEvtOverlay) {
    backgroundDigitContainer = std::make_unique<TileMutableDigitsContainer>(true,
                                                                            TileFragHash::Digitizer,
                                                                            TileRawChannelUnit::ADCcounts);
    ATH_CHECK( backgroundDigitContainer->status() );
 
    if (m_onlyUseContainerName) {
      typedef PileUpMergeSvc::TimedList<TileDigitsContainer>::type TimedDigitContList;
      TimedDigitContList digitContList;
      ATH_CHECK( m_mergeSvc->retrieveSubEvtsData(m_inputDigitContainerName, digitContList));
      ATH_MSG_DEBUG( "TileDigitsCnt successfully retrieved ");
 
 
      if (digitContList.size() == 0) {
        ATH_MSG_WARNING( "No overlay done ... ");
        return StatusCode::SUCCESS;
      }
 
      TimedDigitContList::iterator iTzeroDigitCont(digitContList.begin());
      for (const auto* digitCollection : *(iTzeroDigitCont->second)) {
        for (const auto* digit : *digitCollection) {
          auto pDigits = std::make_unique<TileDigits>(*digit);
          ATH_CHECK(backgroundDigitContainer->push_back(std::move(pDigits)));
        }
      }
    }
    else {
      SG::ReadHandle<TileDigitsContainer> tileDigitsContainerHandle(m_inputDigitContainerKey, ctx);
      if (tileDigitsContainerHandle.isValid()) {
        for (const auto* digitCollection : *tileDigitsContainerHandle) {
          for (const auto* digit : *digitCollection) {
            auto pDigits = std::make_unique<TileDigits>(*digit);
            ATH_CHECK(backgroundDigitContainer->push_back(std::move(pDigits)));
          }
        }
      }
      else {
        ATH_MSG_ERROR("ReadHandle to Background Digits is invalid.");
        return StatusCode::FAILURE;
      }
    }
 
    collItrRndm = backgroundDigitContainer->begin();
    lastCollRndm = backgroundDigitContainer->end();
  }
 
  SG::ReadCondHandle<TileEMScale> emScale(m_emScaleKey, ctx);
  ATH_CHECK( emScale.isValid() );
 
  const TilePulse* pulse = nullptr;
  if (m_useCoolPulseShapes) {
    SG::ReadCondHandle<TilePulse> pulseShape(m_pulseShapeKey, ctx);
    ATH_CHECK( pulseShape.isValid() );
    pulse = pulseShape.retrieve();
  }
 
  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
  ATH_CHECK( samplingFraction.isValid() );
 
  const TileDQstatus* dqStatus = nullptr;
  if (m_rndmEvtOverlay) {
    SG::ReadHandle<TileDQstatus> DQstatusHandle(m_DQstatusKey, ctx);
    ATH_CHECK( DQstatusHandle.isValid() );
    dqStatus = DQstatusHandle.get();
  }
 
  const TileBadChannels* badChannels = nullptr;
  if (m_maskBadChannels || m_rndmEvtOverlay) {
    SG::ReadCondHandle<TileBadChannels> badChannelsHandle(m_badChannelsKey,ctx);
    ATH_CHECK( badChannelsHandle.isValid() );
    badChannels = badChannelsHandle.retrieve();
  }
 
  // iterate over all collections in a container
  // Hit Container and signal hit container are the same size (1 entry per channel)
  TileHitContainer::const_iterator collItr_DigiHSTruth;
  if(m_doDigiTruth) collItr_DigiHSTruth = hitContainer_DigiHSTruth->begin();
 
  /* ----------------------------------------------------------------- */
  /* Begin loop over the Hit collections.  All collections are defined */
  /* (even if they have no hits), and all the digit information        */
  /* including pileup events are contained in the collection.          */
  /*-------------------------------------------------------------------*/
  for (const TileHitCollection* hitCollection : *hitContainer) {
    /* Get array of HWID's for this drawer (stored locally). */
    HWIdentifier drawer_id = m_tileHWID->drawer_id(hitCollection->identify());
    int ros = m_tileHWID->ros(drawer_id);
    int drawer = m_tileHWID->drawer(drawer_id);
    int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
    if (m_cabling->connected(ros, drawer)) {
      ATH_MSG_VERBOSE( "ROS "<< ros << " drawer " << drawer << " is connected");
    } else {
      if (m_rndmEvtOverlay && collItrRndm != lastCollRndm) {
        ++collItrRndm; // skip also one drawer in digi overlay container
      }
      if (m_doDigiTruth) {
        ++collItr_DigiHSTruth;
      } // End DigiHSTruth stuff
      continue;
    }
 
    m_tileHWID->get_hash(drawer_id, idhash, &drawer_context);
    const std::unique_ptr<HWIdentifier[]>& adc_ids = m_all_ids[idhash];
 
    /* Initialize gain settings.  If noise is requested, all channels are */
    /* set to be active.  If not, set them all to be inactive (gain=-1).  */
    /* Only those which contain actual hits will be set active when the   */
    /* hits are read in.                                                  */
    int igainch = (m_allChannels) ? TileID::HIGHGAIN : -1;
    if (m_rndmEvtOverlay) {
      std::fill(over_gain.begin(), over_gain.end(), -1);
    } else if (m_tileNoise || m_tileCoherNoise) {
      igainch = TileID::HIGHGAIN;
    }
 
    std::fill(ech_tot.begin(), ech_tot.end(), 0.0);
    std::fill(ech_int.begin(), ech_int.end(), 0.0);
    std::fill(ntot_ch.begin(), ntot_ch.end(), 0);
    std::fill(igain.begin(), igain.end(), igainch);
 
    std::vector<std::reference_wrapper<std::vector<std::vector<double>>>> drawerBuffers{drawerBufferHi, drawerBufferLo};
    if (m_doDigiTruth) {
      drawerBuffers.push_back(drawerBufferHi_DigiHSTruth);
      drawerBuffers.push_back(drawerBufferLo_DigiHSTruth);
    }
    for (std::vector<std::vector<double>>& drawerBuffer : drawerBuffers) {
      for (std::vector<double>& digitsBuffer : drawerBuffer) {
        std::fill(digitsBuffer.begin(), digitsBuffer.end(), 0);
      }
    }
 
    if (m_rndmEvtOverlay && collItrRndm != lastCollRndm) {
      const TileDigitsCollection *bkgDigitCollection(*collItrRndm);
      ATH_CHECK(overlayBackgroundDigits(bkgDigitCollection, hitCollection, drawerBufferLo, drawerBufferHi,
                                        igain, ros, drawer, drawerIdx, over_gain, *emScale, *sampleNoise, dqStatus, badChannels));
      ++collItrRndm; // skip to next digi collection
    }
 
    std::vector<bool> signal_in_channel(nchMax, false);
    std::vector<bool> signal_in_channel_DigiHSTruth(nchMax, false);
    ATH_CHECK(fillDigitCollection( hitCollection, drawerBufferLo, drawerBufferHi,
                                   igain, over_gain, ech_int, signal_in_channel, *emScale, *samplingFraction, pulse));
    if(m_doDigiTruth){
      ATH_CHECK(fillDigitCollection( *collItr_DigiHSTruth, drawerBufferLo_DigiHSTruth, drawerBufferHi_DigiHSTruth,
                                     igain, over_gain, ech_int_DigiHSTruth, signal_in_channel_DigiHSTruth, *emScale, *samplingFraction, pulse));
    } // End DigiHSTruth stuff
 
    /* Now all signals for this collection are stored in m_drawerBuffer, 
     accessed with digitSamplesHi and digitSampleLo. */
    if (msgLvl(MSG::VERBOSE)) {
      for (int ich = 0; ich < nchMax; ++ich) {
        if (igain[ich] > -1) {
          std::vector<double>& digitSamplesHi = drawerBufferHi[ich];
          std::vector<double>& digitSamplesLo = drawerBufferLo[ich];
          msg(MSG::VERBOSE) << "total:  ADC " << m_tileHWID->to_string(adc_ids[ich],-1) << "/" << igain[ich] 
                            << " nhit=" << ntot_ch[ich]
                            << " e_ch=" << ech_tot[ich]
                            << " AinTHi=" << digitSamplesHi[m_iTrig]
                            << " AinTLo=" << digitSamplesLo[m_iTrig] << endmsg;
        }
      }
    }
 
    /* ---------------------------------------------------------------      */
    /* Now all signals for this drawer are stored in m_drawerBuffer arrays, */
    /* and we are finished with TileHits for this collection.  Loop over    */
    /* channels to add noise and pedestal.  Check for saturation for        */
    /* each channel, and in case of saturation convert to low gain.         */
    /* -------------------------------------------------------------- */
 
    // =============CORRELATION MODIFICATION (F Spano)============== 
    //
    // Define CoVariance Matrix corresponding to noise.
    // TO UPDATE:: Such Matrix will have to be loaded from database in the future; 1 matrix per drawer.
    // NOW: 
    // a) define one covariance matrix
    // b) find Cholesky decomposition use for corrlation building
    // if this is set load the matrix
    if (m_tileCoherNoise) {
      ATH_MSG_VERBOSE( "Coherent noise for ROS " << ros
                       << " drawer " << drawer
                       << " with " << nchMax << " channels and "
                       << m_nSamples << "samples ");
 
      // get decomposed covariance matrix for hi gain
      coherNoiseHi = 1;
      if (coherNoiseHi) {
        CorrWeightHi.ResizeTo(*(m_tileInfo->DecoCovariance(ros, drawer, TileID::HIGHGAIN)));
        CorrWeightHi = *(m_tileInfo->DecoCovariance(ros, drawer, TileID::HIGHGAIN));
      }
 
      // get decomposed covariance matrix for low gain
      coherNoiseLo = 1;
      if (coherNoiseLo) {
        CorrWeightLo.ResizeTo(*(m_tileInfo->DecoCovariance(ros, drawer, TileID::LOWGAIN)));
        CorrWeightLo = *(m_tileInfo->DecoCovariance(ros, drawer, TileID::LOWGAIN));
      }
 
      //NOTE: ShootArray's inputs are : the engine, the size, the vector, the mean, the standard dev
      for (int k = 0; k < m_nSamples; ++k) {
        double* RndmVec = CorrRndmVec[k].get();
        RandGaussQ::shootArray(rngEngine, nchMax, RndmVec, 0.0, 1.0);
      }
 
      if (m_calibRun) {
        for (int k = 0; k < m_nSamples; ++k) {
          double * RndmVecLo = CorrRndmVecLo[k].get();
          RandGaussQ::shootArray(rngEngine, nchMax, RndmVecLo, 0.0, 1.0);
        }
      }
    }
    // =============CORRELATION MODIFICATION (F Spano)============== end
 
    // looping over channels
    for (int ich = 0; ich < nchMax; ++ich) {
      /* If igain<0, channel is inactive => skip it.                    */
      if (igain[ich] < 0)
        continue;
 
      /* Generate the nSamp Digits for high gain. Check each for saturation. */
      ++nChHiSum;
      HWIdentifier adc_id = adc_ids[ich];
      HWIdentifier adc_id_lo; // for calib runs
      Identifier pmt_id = m_cabling->h2s_pmt_id(adc_id);
      ATH_MSG_DEBUG( "Ch " << m_tileHWID->to_string(adc_id,-1)
                     << " PMT " << (pmt_id.is_valid() ? m_tileID->to_string(pmt_id,-1) : (signal_in_channel[ich] ? "fake gap" : "not connected"))
                     << " gain=" << igain[ich]);
 
      if (m_calibRun || m_maskBadChannels) {
        adc_id_lo = m_tileHWID->adc_id(drawer_id, ich, TileID::LOWGAIN);
        if (m_calibRun) {
          ++nChLoSum;
        }
      }
 
      bool chanLoIsBad = false;
      bool chanHiIsBad = false;
      if (m_maskBadChannels) {
        TileBchStatus statusLo = badChannels->getAdcStatus(adc_id_lo);
        TileBchStatus statusHi = badChannels->getAdcStatus(adc_id);
        chanLoIsBad = statusLo.isBad();
        chanHiIsBad = statusHi.isBad();
      }
 
      /* Get pedestal and noise values */
      double pedSimHi(0.), sigmaHi_Hfn1(0.), sigmaHi_Hfn2(0.), sigmaHi_Norm(0.), pedSimLo(0.),
          sigmaLo_Hfn1(0.), sigmaLo_Hfn2(0.), sigmaLo_Norm(0.);
      bool good_ch = (over_gain[ich]<9);
      bool overNoiseHG(over_gain[ich]!=TileID::HIGHGAIN && good_ch); // it's always true if no overlay
      bool overNoiseLG(over_gain[ich]!=TileID::LOWGAIN  && good_ch); // it's always true if no overlay
      bool tileNoiseHG(false),tileNoiseLG(false);
 
      if (overNoiseHG) {
        overNoiseHG &= (m_rndmEvtOverlay && m_allChannels>1); // set it to true only for overlay
        tileNoiseHG = m_tileNoise || overNoiseHG;
 
        pedSimHi = sampleNoise->getPed(idhash, ich, TileID::HIGHGAIN);
        // bug fix for wrong ped value in DB
        if (pedSimHi == 0.0 && (signal_in_channel[ich] || pmt_id.is_valid()))
          pedSimHi = 50.;
 
        sigmaHi_Hfn1 = sampleNoise->getHfn1(idhash, ich, TileID::HIGHGAIN);
        sigmaHi_Hfn2 = sampleNoise->getHfn2(idhash, ich, TileID::HIGHGAIN);
        if (sigmaHi_Hfn1>0 || sigmaHi_Hfn2) {
          sigmaHi_Norm = sigmaHi_Hfn1 / (sigmaHi_Hfn1
                       + sigmaHi_Hfn2 * sampleNoise->getHfnNorm(idhash, ich, TileID::HIGHGAIN));
        } else {
          sigmaHi_Hfn1 = sampleNoise->getHfn(idhash, ich, TileID::HIGHGAIN);
          sigmaHi_Norm = 1.;
        }
      }
      
      if (overNoiseLG) {
        overNoiseLG &= (m_rndmEvtOverlay && m_allChannels>1); // set it to true only for overlay
        tileNoiseLG = m_tileNoise || overNoiseLG;
 
        pedSimLo = sampleNoise->getPed(idhash, ich, TileID::LOWGAIN);
        // bug fix for wrong ped value in DB
        if (pedSimLo == 0.0 && (signal_in_channel[ich] || pmt_id.is_valid()))
          pedSimLo = 30.;
 
        sigmaLo_Hfn1 = sampleNoise->getHfn1(idhash, ich, TileID::LOWGAIN);
        sigmaLo_Hfn2 = sampleNoise->getHfn2(idhash, ich, TileID::LOWGAIN);
        if (sigmaLo_Hfn1 > 0 || sigmaLo_Hfn2) {
          sigmaLo_Norm = sigmaLo_Hfn1 / (sigmaLo_Hfn1
                       + sigmaLo_Hfn2 * sampleNoise->getHfnNorm(idhash, ich, TileID::LOWGAIN));
        } else {
          sigmaLo_Hfn1 = sampleNoise->getHfn(idhash, ich, TileID::LOWGAIN);
          sigmaLo_Norm = 1.;
        }
      }
 
      /* If tileNoise is requested, generate array of random numbers.   */
      if (tileNoiseLG) { // true if tileNoise is set or noise is needed for low gain in overlay
        RandGaussQ::shootArray(rngEngine, m_nSamples, Rndm, 0.0, 1.0);
        RandFlat::shootArray(rngEngine, 1, Rndm_dG, 0.0, 1.0);
        if (m_calibRun) {
          RandGaussQ::shootArray(rngEngine, m_nSamples, RndmLo, 0.0, 1.0);
          RandFlat::shootArray(rngEngine, 1, RndmLo_dG, 0.0, 1.0);
        }
      }
 
      std::vector<double>& digitSamplesHi = drawerBufferHi[ich];
      std::vector<double>& digitSamplesLo = drawerBufferLo[ich];
      std::vector<double>& digitSamplesHi_DigiHSTruth = (m_doDigiTruth) ? drawerBufferHi_DigiHSTruth[ich] : emptyBuffer;
      std::vector<double>& digitSamplesLo_DigiHSTruth = (m_doDigiTruth) ? drawerBufferLo_DigiHSTruth[ich] : emptyBuffer;
 
      ATH_MSG_DEBUG(" Channel " << ros << '/' << drawer << '/' << ich 
                     << " sampHi=" << digitSamplesHi[m_iTrig]
                     << " pedHi=" << pedSimHi
                     << " sampLo=" << digitSamplesLo[m_iTrig]
                     << " pedLo=" << pedSimLo);
 
      // looping over samples
      for (int js = 0; js < m_nSamples; ++js) {
 
        digitsBuffer[js] = digitSamplesHi[js] + pedSimHi;
        if(m_doDigiTruth) {
          digitsBuffer_DigiHSTruth[js] = digitSamplesHi_DigiHSTruth[js] + pedSimHi;
        }
 
        double noiseHi(0.0);
        // Full noise pattern, including coherent noise has priority over normal noise //F Spano'
        if (coherNoiseHi) {
          // get the js-th  correct random vector of 48 elements for the jsth sample k  //F Spano'
          std::unique_ptr<double[]>& CorVec = CorrRndmVec[js];
          // apply Y=C*Z where Z is the random vector of 48 normal indep variables, and C is the Cholesky decomposition //F Spano'
          for (int i = 0; i < nchMax; ++i) noiseHi += CorrWeightHi(i, ich) * CorVec[i];
        } else if (tileNoiseHG) {
          //using the same gaussian(sigma) for all samples in one channel in one event
          if (Rndm_dG[0] < sigmaHi_Norm) noiseHi = sigmaHi_Hfn1 * Rndm[js];
          else noiseHi = sigmaHi_Hfn2 * Rndm[js];
        }
 
        if (digitsBuffer[js] + noiseHi >= 0.0) {
          digitsBuffer[js] += noiseHi;
          if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] += noiseHi;
        } else {
          digitsBuffer[js] -= noiseHi;
          if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] -= noiseHi;
        }
 
 
        if (m_integerDigits) {
          digitsBuffer[js] = round(digitsBuffer[js]);
          if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] = round(digitsBuffer_DigiHSTruth[js]);
        }
 
        if (m_calibRun) { //Calculate also low gain
          digitsBufferLo[js] = digitSamplesLo[js] + pedSimLo;
          if(m_doDigiTruth) digitsBufferLo_DigiHSTruth[js] = digitSamplesLo_DigiHSTruth[js] + pedSimLo;
          double noiseLo(0.0);
          // Full noise pattern, including coherent noise has priority over normal noise //F Spano'
          if (coherNoiseLo) {
            // get the js-th  correct random vector of 48 elements for the jsth sample // F Spano'
            std::unique_ptr<double[]>& CorVecLo = CorrRndmVecLo[js];
            // apply Y=C*Z where Z is the random vector of 48 normal indep variables, and C is the Cholesky decomposition // F Spano'
            for (int i = 0; i < nchMax; ++i) noiseLo += CorrWeightLo(i, ich) * CorVecLo[i];
          } else if (tileNoiseLG) {
            //using the same gaussian (sigma) for all samples in one channel in one event
            if (RndmLo_dG[0] < sigmaLo_Norm) noiseLo = sigmaLo_Hfn1 * RndmLo[js];
            else noiseLo = sigmaLo_Hfn2 * RndmLo[js];
          }
          
          if (digitsBufferLo[js] + noiseLo >= 0.0) {
            digitsBufferLo[js] += noiseLo;
            if(m_doDigiTruth) digitsBufferLo_DigiHSTruth[js] += noiseLo;
          } else {
            digitsBufferLo[js] -= noiseLo;
            if(m_doDigiTruth) digitsBufferLo_DigiHSTruth[js] -= noiseLo;
          }
          
          if (m_integerDigits) {
            digitsBufferLo[js] = round(digitsBufferLo[js]);
            if(m_doDigiTruth) digitsBufferLo_DigiHSTruth[js] = round(digitsBufferLo_DigiHSTruth[js]);
          }
 
 
        } else if ((digitsBuffer[js] >= m_f_ADCmaxHG && good_ch) || igain[ich] == TileID::LOWGAIN) { // saturation of high gain in non-calib run
                                                                                                 // or low gain in digi overlay
          --nChHiSum;
          ++nChLoSum;
          igain[ich] = TileID::LOWGAIN;
          adc_id = m_tileHWID->adc_id(drawer_id, ich, TileID::LOWGAIN);
 
          // reset all samples in digitsBuffer[] to Low Gain values
          for (js = 0; js < m_nSamples; ++js) {
            digitsBuffer[js] = digitSamplesLo[js] + pedSimLo;
            if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] = digitSamplesLo_DigiHSTruth[js] + pedSimLo;
            double noiseLo(0.0);
            // Full noise pattern, including coherent noise has priority over normal noise //F Spano'
            if (coherNoiseLo) {
              // get the js-th  correct random vector of 48 elements for the jsth sample // F Spano'
              double* CorVec = CorrRndmVec[js].get(); // reuse the same rndm as for high gain
              // apply Y=C*Z where Z is the random vector of 48 normal indep variables, and C is the Cholesky decomposition // F Spano'
              for (int i = 0; i < nchMax; ++i) noiseLo += CorrWeightLo(i, ich) * CorVec[i];
            } else if (tileNoiseLG) {
              //using the same gaussian (sigma) for all samples in one channel in one event
                // reuse the same rndm as for high gain
              if (Rndm_dG[0] < sigmaLo_Norm) noiseLo = sigmaLo_Hfn1 * Rndm[js];
              else noiseLo = sigmaLo_Hfn2 * Rndm[js];
            }
 
            if (digitsBuffer[js] + noiseLo >= 0.0) {
              digitsBuffer[js] += noiseLo;
              if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] += noiseLo;
            } else {
              digitsBuffer[js] -= noiseLo;
              if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] -= noiseLo;
            }
 
            if (digitsBuffer[js] > m_f_ADCmax && good_ch) {
              digitsBuffer[js] = m_f_ADCmax;
              if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] = m_f_ADCmax;
            }
            if (m_integerDigits) {
              digitsBuffer[js] = round(digitsBuffer[js]);
              if(m_doDigiTruth) digitsBuffer_DigiHSTruth[js] = round(digitsBuffer_DigiHSTruth[js]);
            }
          }
 
          overNoiseHG = false;
 
          if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "Channel " << ros << '/' << drawer << '/' << ich << "/" << igain[ich]
                              << "  Switch to low gain  Amp(lo)=" << digitsBuffer[m_iTrig] << endmsg;
            if (overNoiseLG) {
              if (sigmaLo_Norm<1.0) {
                msg(MSG::VERBOSE) << "LG Ped & noise from DB "
                                  << pedSimLo << " " << sigmaLo_Hfn1 << " " << sigmaLo_Hfn2 << " " << sigmaLo_Norm
                                  << ((Rndm_dG[0] < sigmaLo_Norm)?(" sig1 used"):(" sig2 used")) << endmsg;
              } else {
                msg(MSG::VERBOSE) << "LG Ped & noise from DB "
                                  << pedSimLo << " " << sigmaLo_Hfn1 << endmsg;
              }
            }
          }
          break;
        }
      }
      if (msgLvl(MSG::VERBOSE)) {
        if (overNoiseHG) {
          if (sigmaHi_Norm<1.0) {
            msg(MSG::VERBOSE) << "HG Ped & noise from DB " 
                              << pedSimHi << " " << sigmaHi_Hfn1 << " " << sigmaHi_Hfn2 << " " << sigmaHi_Norm
                              << ((Rndm_dG[0] < sigmaHi_Norm)?(" sig1 used"):(" sig2 used")) << endmsg;
          } else {
            msg(MSG::VERBOSE) << "HG Ped & noise from DB " 
                              << pedSimHi << " " << sigmaHi_Hfn1 << endmsg;
          }
        }
        if (m_calibRun && overNoiseLG) {
          if (sigmaLo_Norm<1.0) {
            msg(MSG::VERBOSE) << "LG Ped & noise from DB "
                              << pedSimLo << " " << sigmaLo_Hfn1 << " " << sigmaLo_Hfn2 << " " << sigmaLo_Norm
                              << ((RndmLo_dG[0] < sigmaLo_Norm)?(" sig1 used"):(" sig2 used")) << endmsg;
          } else {
            msg(MSG::VERBOSE) << "LG Ped & noise from DB "
                              << pedSimLo << " " << sigmaLo_Hfn1 << endmsg;
          }
        }
      }
 
      if (m_calibRun) { // calib run - keep both low and high gain
 
        if (chanHiIsBad) {
          std::fill(digitsBuffer.begin(), digitsBuffer.end(), m_f_ADCmaskValue);
          if (m_doDigiTruth) {
            std::fill(digitsBuffer_DigiHSTruth.begin(), digitsBuffer_DigiHSTruth.end(), m_f_ADCmaskValue);
          }
          ATH_MSG_DEBUG( "Masking Channel " << ros << '/' << drawer << '/' << ich << "/1 HG" );
        }
 
        auto pDigits = std::make_unique<TileDigits>(adc_id, digitsBuffer);
        ATH_CHECK( digitsContainer->push_back(std::move(pDigits)) );
 
        if(m_doDigiTruth && digitsContainer_DigiHSTruth){
          auto digits_DigiHSTruth = std::make_unique<TileDigits>(adc_id, digitsBuffer_DigiHSTruth);
          ATH_CHECK( digitsContainer_DigiHSTruth->push_back(std::move(digits_DigiHSTruth)) );
        }
 
        if (chanLoIsBad) {
          std::fill(digitsBufferLo.begin(), digitsBufferLo.end(), m_f_ADCmaskValue);
          if(m_doDigiTruth) {
            std::fill(digitsBufferLo_DigiHSTruth.begin(), digitsBufferLo_DigiHSTruth.end(), m_f_ADCmaskValue);
          }
 
          ATH_MSG_DEBUG( "Masking Channel " << ros << '/' << drawer << '/' << ich << "/0 LG");
        }
 
        auto pDigitsLo = std::make_unique<TileDigits>(adc_id_lo, digitsBufferLo);
        ATH_CHECK( digitsContainer->push_back(std::move(pDigitsLo)) );
 
        if(m_doDigiTruth && digitsContainer_DigiHSTruth){
          auto pDigitsLo_DigiHSTruth = std::make_unique<TileDigits>(adc_id_lo, digitsBufferLo_DigiHSTruth);
          ATH_CHECK( digitsContainer_DigiHSTruth->push_back(std::move(pDigitsLo_DigiHSTruth)) );
        }
      } else { //normal run
 
        bool hiGain = (igain[ich] == TileID::HIGHGAIN);
 
        // If tileThresh, apply threshold cut to the in-time Digits signal
        bool isChannelGood = true;
        if (m_tileThresh) {
          if (hiGain) { // make threshold only on high gain
            double ampInTime = digitsBuffer[m_iTrig] - pedSimHi;
            if (m_integerDigits)
              ampInTime = round(ampInTime);
            if (m_tileThreshHi < 0) {
              if (fabs(ampInTime) < fabs(m_tileThreshHi))
                isChannelGood = false;
            } else {
              if (ampInTime < m_tileThreshHi)
                isChannelGood = false;
            }
          }
        }
        // If channel is good, create TileDigits object and store in container.
        if (isChannelGood) {
          echtot_Acc += ech_tot[ich];
          echint_Acc += fabs(ech_int[ich]);
          if (hiGain) {
            ++nChHiAcc;
          } else {
            ++nChLoAcc;
          }
 
          if (hiGain) {
            //if (m_rndmEvtOverlay // not needed, because DQstatus have been already checked before
            //    && !(theDQstatus->isAdcDQgood(ros, drawer, ich, TileID::HIGHGAIN))) {
            //  chanHiIsBad = true;
            //  ATH_MSG_DEBUG( "BAD DQ Channel " << ros << '/' << drawer << '/' << ich << "/1 HG");
            //}
            if (chanHiIsBad) {
              if (pmt_id.is_valid()) {
                std::fill(digitsBuffer.begin(), digitsBuffer.end(), m_f_ADCmaskValue);
                if (m_doDigiTruth) {
                  std::fill(digitsBuffer_DigiHSTruth.begin(), digitsBuffer_DigiHSTruth.end(), m_f_ADCmaskValue);
                }
              } else if (good_ch) {
                ATH_MSG_DEBUG( "Disconnected Channel " << ros << '/' << drawer << '/' << ich);
                std::fill(digitsBuffer.begin(), digitsBuffer.end(), 0.);
                if (m_doDigiTruth) {
                  std::fill(digitsBuffer_DigiHSTruth.begin(), digitsBuffer_DigiHSTruth.end(), 0.);
                }
              }
              ATH_MSG_DEBUG( "Masking Channel " << ros << '/' << drawer << '/' << ich << "/1 HG");
            }
          } else {
            //if (m_rndmEvtOverlay // not needed, because DQstatus have been already checked before
            //    && !(theDQstatus->isAdcDQgood(ros, drawer, ich, TileID::LOWGAIN))) {
            //  chanLoIsBad = true;
            //  ATH_MSG_DEBUG( "BAD DQ Channel " << ros << '/' << drawer << '/' << ich << "/0 LG");
            //}
            if (chanLoIsBad) {
              if (pmt_id.is_valid()) {
                std::fill(digitsBuffer.begin(), digitsBuffer.end(), m_f_ADCmaskValue);
                if (m_doDigiTruth) {
                  std::fill(digitsBuffer_DigiHSTruth.begin(), digitsBuffer_DigiHSTruth.end(), m_f_ADCmaskValue);
                }
              } else if (good_ch) {
                ATH_MSG_DEBUG( "Disconnected Channel " << ros << '/' << drawer << '/' << ich);
                std::fill(digitsBuffer.begin(), digitsBuffer.end(), 0.);
                if (m_doDigiTruth) {
                  std::fill(digitsBuffer_DigiHSTruth.begin(), digitsBuffer_DigiHSTruth.end(), 0.);
                }
              }
              ATH_MSG_DEBUG( "Masking Channel " << ros << '/' << drawer << '/' << ich << "/0 LG");
            }
          }
 
          auto pDigits = std::make_unique<TileDigits>(adc_id, digitsBuffer);
 
          if (ech_int[ich] > m_filterThreshold || ech_int[ich] < -m_filterThresholdMBTS) {
            if (filteredContainer) ATH_CHECK( filteredContainer->push_back(pDigits.get()) );
            if (hiGain) {
              ++nChHiFlt;
            } else {
              ++nChLoFlt;
            }
          }
 
          ATH_CHECK( digitsContainer->push_back(std::move(pDigits)) );
          if(m_doDigiTruth && digitsContainer_DigiHSTruth){
            auto pDigits_DigiHSTruth = std::make_unique<TileDigits>(adc_id, digitsBuffer_DigiHSTruth);
            ATH_CHECK( digitsContainer_DigiHSTruth->push_back(std::move(pDigits_DigiHSTruth)) );
          }
 
          if (msgLvl(MSG::VERBOSE)) {
            double pedSim = ((hiGain) ? pedSimHi : pedSimLo);
            double ampInTime = digitsBuffer[m_iTrig] - pedSim;
            if (m_integerDigits)
              ampInTime = round(ampInTime);
            msg(MSG::VERBOSE) << ((ech_int[ich] > m_filterThreshold
                                  || ech_int[ich] < -m_filterThresholdMBTS) ? "AccFlt" : "Accept")
                              << " ADC " << m_tileHWID->to_string(adc_id)
                              << " AinT=" << ampInTime
                              << " ped=" << pedSim
                              << " Ech=" << ech_tot[ich]
                              << " EinT=" << ech_int[ich] << endmsg;
            msg(MSG::VERBOSE) << "digits";
            for (unsigned int i = 0; i < digitsBuffer.size(); ++i)
              msg(MSG::VERBOSE) << " " << digitsBuffer[i];
            msg(MSG::VERBOSE) << endmsg;
          }
        } else {
          echtot_Cut += ech_tot[ich];
          echint_Cut += ech_int[ich];
          if (hiGain) {
            ++nChHiCut;
          } else {
            ++nChLoCut;
          }
 
          if (msgLvl(MSG::VERBOSE)) {
            double pedSim = ((hiGain) ? pedSimHi : pedSimLo);
            double ampInTime = digitsBuffer[m_iTrig] - pedSim;
            if (m_integerDigits)
              ampInTime = round(ampInTime);
            msg(MSG::VERBOSE) << "Reject. ADC " << m_tileHWID->to_string(adc_id)
                              << " AinT=" << ampInTime
                              << " ped=" << pedSim
                              << " Ech=" << ech_tot[ich]
                              << " EinT=" << ech_int[ich] << endmsg;
          }
        }
      }
    }
    if(m_doDigiTruth) ++collItr_DigiHSTruth;
  }
 
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << "TileDigitsMaker execution completed." << endmsg;
    msg(MSG::DEBUG) << " nCh=" << nChSum
                    << " nChH/L=" << nChHiSum << "/" << nChLoSum
                    << " nFltH/L=" << nChHiFlt << "/" << nChLoFlt
                    << " Hit=" << HitSum
                    << " Ene=" << EneSum
                    << " RChSum=" << RChSum << endmsg;
    if (m_tileThresh) {
      msg(MSG::DEBUG) << " Accepted:  nChLo/Hi=" << nChLoAcc << "/" << nChHiAcc
                      << " eTot=" << echtot_Acc
                      << " eInT=" << echint_Acc << endmsg;
      msg(MSG::DEBUG) << " Rejected: nChLo/Hi=" << nChLoCut << "/" << nChHiCut
                      << " eTot=" << echtot_Cut
                      << " eInT=" << echint_Cut << endmsg;
    }
  }
 
 
  // step3: register the Digit container in the TES
  SG::WriteHandle<TileDigitsContainer> digitsCnt(m_digitsContainerKey, ctx);
  ATH_CHECK( digitsCnt.record(std::move(digitsContainer)) );
 
  if(m_doDigiTruth && digitsContainer_DigiHSTruth){
    SG::WriteHandle<TileDigitsContainer> digits_DigiHSTruth(m_digitsContainer_DigiHSTruthKey, ctx);
    ATH_CHECK( digits_DigiHSTruth.record(std::move(digitsContainer_DigiHSTruth)) );
  }
 
  if (filteredContainer) {
    SG::WriteHandle<TileDigitsContainer> filteredDigitsContainer(m_filteredDigitsContainerKey, ctx);
    ATH_CHECK( filteredDigitsContainer.record(std::move(filteredContainer)) );
  }
 
  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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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();
}

fillDigitCollection()

StatusCode TileDigitsMaker::fillDigitCollection ( const TileHitCollection * hitCollection, std::vector< std::vector< double > > & drawerBufferLo, std::vector< std::vector< double > > & drawerBufferHi, std::vector< int > & igain, std::vector< int > & overgain, std::vector< double > & ech_int, std::vector< bool > & signal_in_channel, const TileEMScale * emScale, const TileSamplingFraction * samplingFraction, const TilePulse * pulse ) const

private

Definition at line 1094 of file TileDigitsMaker.cxx.

                                                                                                                           {
  
  constexpr int nchMax = 48; // number of channels per drawer
  std::array<int, nchMax> ntot_ch; ntot_ch.fill(0);
  std::array<double, nchMax> ech_tot; ech_tot.fill(0.0);
  //double ech_int[nchMax];
 
  IdContext drawer_context = m_tileHWID->drawer_context();
 
  /* Set up buffers for handling information in a single collection. */
  HWIdentifier drawer_id = m_tileHWID->drawer_id(hitCollection->identify());
  int ros = m_tileHWID->ros(drawer_id);
  int drawer = m_tileHWID->drawer(drawer_id);
  int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
 
  // iterate over all hits in a collection
  for (const TileHit* tileHit : *hitCollection) {
 
    /* Get hit Identifier (= pmt_ID) and needed parameters for this channel */
    Identifier pmt_id = tileHit->pmt_ID();
    double mbts_extra_factor = (m_tileTBID->is_tiletb(pmt_id)) ? -1.0 : 1.0;
    HWIdentifier channel_id = tileHit->pmt_HWID();
    int ich = m_tileHWID->channel(channel_id);
    signal_in_channel[ich] = true;
 
    if (over_gain[ich] > 9) {
      if (msgLvl(MSG::DEBUG)) {
        int n_hits = tileHit->size();
        double e_hit(0.);
        for (int ihit = 0; ihit < n_hits; ++ihit) {
          e_hit += tileHit->energy(ihit);
        }
        e_hit *= std::round(samplingFraction->getSamplingFraction(drawerIdx, ich) * 1000) / 1000;
        ech_tot[ich] += e_hit;
        ntot_ch[ich] += n_hits;
        ATH_MSG_VERBOSE("BAD Overlay digits - skip hit in channel " << m_tileHWID->to_string(channel_id,-1));
      }
      continue;
    } else {
      ATH_MSG_VERBOSE("new hit in channel " << m_tileHWID->to_string(channel_id,-1));
    }
 
    /* Set gain=high and get digitSamples and calibration for this channel. */
    if (igain[ich] < 0)
      igain[ich] = TileID::HIGHGAIN;
    // conversion from scintillator energy to total cell energy (sampling fraction)  
    double hit_calib = samplingFraction->getSamplingFraction(drawerIdx, ich);
    hit_calib = std::round(hit_calib * 1000) / 1000;
 
    // conversion to ADC counts for high gain
    double efactorHi = hit_calib / emScale->calibrateChannel(drawerIdx, ich, TileID::HIGHGAIN, 1.
                                    , TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
    // conversion to ADC counts for low gain
    double efactorLo = hit_calib / emScale->calibrateChannel(drawerIdx, ich, TileID::LOWGAIN, 1.
                                  , TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
 
    std::vector<double>& digitSamplesHi = drawerBufferHi[ich];
    std::vector<double>& digitSamplesLo = drawerBufferLo[ich];
    /* Loop over the subhits for this channel.  For each one,
     convolute with shaping function and add to digitSamples.                  */
    int n_hits = tileHit->size();
    for (int ihit = 0; ihit < n_hits; ++ihit) {
      /* Get hit energy and convert to amplitude of high-gain and low-gain channel */
      double e_hit = tileHit->energy(ihit);
      double amp_ch = e_hit * efactorHi;
      double amp_ch_lo = e_hit * efactorLo;
      double ech_sub = e_hit * hit_calib;
      double t_hit = tileHit->time(ihit);
 
      ech_tot[ich] += ech_sub;
      if (fabs(t_hit) < 50.0) // ene within +/- 50 ns, used for filtered digits cut
        ech_int[ich] += ech_sub * mbts_extra_factor;
      ntot_ch[ich] += 1;
 
      // Assume time is in nanoseconds, use fine-grain shaping:
      int ishiftHi = (int) (t_hit / m_timeStepHi + 0.5);
      for (int js = 0; js < m_nSamples; ++js) {
        int k = m_binTime0Hi + (js - m_iTrig) * m_nBinsPerXHi - ishiftHi;
        if (k < 0)
          k = 0;
        else if (k > m_nShapeHi)
          k = m_nShapeHi;
 
        if (m_useCoolPulseShapes) {
          float phase = (k - m_binTime0Hi) * m_timeStepHi;
          float y, dy;
          pulse->getPulseShapeYDY(drawerIdx, ich, 1, phase, y, dy);
          double ampl = (double) y;
          digitSamplesHi[js] += amp_ch * ampl;
          ATH_MSG_VERBOSE( "Sample no.=" << js
                           << " Pulse index=" << k
                           << " Shape wt. =" << ampl
                           << " HIGAIN from COOL");
 
        } else {
          digitSamplesHi[js] += amp_ch * m_digitShapeHi[k];
          ATH_MSG_VERBOSE( "Sample no.=" << js
                           << " Pulse index=" << k
                           << " Shape wt. =" << m_digitShapeHi[k]
                           << " HIGAIN from TileInfo");
        }
 
      }
      int ishiftLo = (int) (t_hit / m_timeStepLo + 0.5);
      for (int js = 0; js < m_nSamples; ++js) {
        int k = m_binTime0Lo + (js - m_iTrig) * m_nBinsPerXLo - ishiftLo;
        if (k < 0)
          k = 0;
        else if (k > m_nShapeLo)
          k = m_nShapeLo;
 
        if (m_useCoolPulseShapes) {
          float phase = (k - m_binTime0Lo) * m_timeStepLo;
          float y, dy;
          pulse->getPulseShapeYDY(drawerIdx, ich, 0, phase, y, dy);
          double ampl = (double) y;
          digitSamplesLo[js] += amp_ch_lo * ampl;
          ATH_MSG_VERBOSE( "Sample no.=" << js
                           << " Pulse index=" << k
                           << " Shape wt. =" << ampl
                           << " LOGAIN from COOL");
        } else {
          digitSamplesLo[js] += amp_ch_lo * m_digitShapeLo[k];
          ATH_MSG_VERBOSE( "Sample no.=" << js
                           << " Pulse index=" << k
                           << " Shape wt. =" << m_digitShapeLo[k]
                           << " LOGAIN from TileInfo");
        }
 
      }
 
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << "subHit:  ch=" << ich
                          << " e_hit=" << e_hit
                          << " t_hit=" << t_hit
                          << " SamplesHi[" << m_iTrig << "]=" << digitSamplesHi[m_iTrig]
                          << " SamplesLo[" << m_iTrig << "]=" << digitSamplesLo[m_iTrig] << endmsg;
      }
    } /* end loop over sub-hits */
  } /* end loop over hits for this collection. */
 
 
  return StatusCode::SUCCESS;
 
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode TileDigitsMaker::finalize ( )

overridevirtual

finalize method

Definition at line 1088 of file TileDigitsMaker.cxx.

                                     {
  ATH_MSG_DEBUG( "TileDigitsMaker finalized successfully");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TileDigitsMaker::initialize ( )

overridevirtual

initialize method

Definition at line 66 of file TileDigitsMaker.cxx.

                                       {
  // retrieve TileID helper and TileInfo from det store
 
  ATH_CHECK( detStore()->retrieve(m_tileID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileTBID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileInfo, m_infoName) );
 
  //=== intialize TileEMScale condtion object
  ATH_CHECK( m_emScaleKey.initialize() );
 
  //=== initialize TileSampleNoise condition object
  ATH_CHECK( m_sampleNoiseKey.initialize() );
 
  ATH_CHECK( m_cablingSvc.retrieve() );
  m_cabling = m_cablingSvc->cablingService();
 
  /* Get needed parameters from tileInfo. */
  m_nSamples = m_tileInfo->NdigitSamples(); // number of time slices for each chan
  m_iTrig = m_tileInfo->ItrigSample();   // index of the triggering time slice
  m_i_ADCmax = m_tileInfo->ADCmax();     // adc saturation value used in assignment
  m_f_ADCmax = m_i_ADCmax;               // adc saturation value used in assignment
  m_f_ADCmaxHG = m_f_ADCmax - 0.5;       // value of switch from high to low gain
  m_ADCmaxMinusEps = m_f_ADCmax - 0.01;
  m_ADCmaxPlusEps = m_f_ADCmax + 0.01;
  m_f_ADCmaskValue = m_tileInfo->ADCmaskValue();               // indicates channels which were masked in background dataset
  m_tileNoise = m_tileInfo->TileNoise(); // (true => generate noise in TileDigits)
  m_tileCoherNoise = m_tileInfo->TileCoherNoise(); // (true => generate coherent noise in TileDigits)
  m_tileThresh = m_tileInfo->TileZeroSuppress(); // (true => apply threshold to Digits)
  m_tileThreshHi = m_tileInfo->ThresholdDigits(TileID::HIGHGAIN);
  m_tileThreshLo = m_tileInfo->ThresholdDigits(TileID::LOWGAIN);
 
  if (m_tileNoise || m_tileCoherNoise || m_rndmEvtOverlay) {
    ATH_CHECK( m_rndmSvc.retrieve());
  }
 
  ATH_MSG_DEBUG( "Event Overlay: " << ((m_rndmEvtOverlay)?"true":"false"));
  ATH_MSG_DEBUG( "Masking Channels: " << ((m_maskBadChannels)?"true":"false"));
  ATH_MSG_DEBUG( "Using pulse shapes from COOL: " << ((m_useCoolPulseShapes)?"true":"false"));
 
  ATH_CHECK( m_pulseShapeKey.initialize(m_useCoolPulseShapes) );
  ATH_CHECK( m_samplingFractionKey.initialize() );
 
  if (m_useCoolPulseShapes) {
    ATH_MSG_DEBUG( "Initializing pulse shape conditions object");
  } else {
    /* Get fine-grained shaping profile (0.5-ns bins) for both gains*/
    m_digitShapeHi = m_tileInfo->digitsFullShapeHi();
    m_digitShapeHi.push_back(0.0);
    m_digitShapeLo = m_tileInfo->digitsFullShapeLo();
    m_digitShapeLo.push_back(0.0);
  }
 
  //=== Initialize bad channels key
  ATH_CHECK( m_badChannelsKey.initialize(m_maskBadChannels || m_rndmEvtOverlay) );
 
  m_nShapeHi = m_tileInfo->digitsNBinsHi();
  m_nBinsPerXHi = m_tileInfo->digitsBinsPerXHi();
  m_binTime0Hi = m_tileInfo->digitsTime0BinHi();
  m_timeStepHi = 25.0 / m_nBinsPerXHi;
 
  m_nShapeLo = m_tileInfo->digitsNBinsLo();
  m_nBinsPerXLo = m_tileInfo->digitsBinsPerXLo();
  m_binTime0Lo = m_tileInfo->digitsTime0BinLo();
  m_timeStepLo = 25.0 / m_nBinsPerXLo;
 
  m_inputDigitContainerName = m_inputDigitContainerKey.key();
  ATH_CHECK( m_inputDigitContainerKey.initialize(!m_onlyUseContainerName && m_rndmEvtOverlay) );
 
  if (m_rndmEvtOverlay) {
    m_tileNoise = false;
    m_tileCoherNoise = false;
    m_tileThresh = false;
    m_calibRun = false;
    if (m_allChannels<0) m_allChannels = 2; // create all channels with noise in overlay by default
 
    ATH_MSG_DEBUG( "Pileup and/or noise added by overlaying digits of random events");
 
    // locate the PileUpMergeSvc and initialize our local ptr
    if (m_onlyUseContainerName) {
      ATH_CHECK( m_mergeSvc.retrieve() );
      ATH_MSG_DEBUG( "PileUpMergeSvc successfully initialized");
    }
 
    ATH_CHECK( m_DQstatusKey.initialize() );
 
  } else {
    ATH_CHECK( m_DQstatusKey.initialize(!m_DQstatusKey.empty()) );
 
    if (m_allChannels<0) m_allChannels = 0;                 // do not create all channels by default
    if (m_tileNoise || m_tileCoherNoise) m_allChannels = 2; // unless noise is set to True
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG) << "Obtained info from TileInfo" << endmsg;
      msg(MSG::DEBUG) << "tileNoise=" << ((m_tileNoise) ? "true" : "false")
                     << ", tileCoherNoise=" << ((m_tileCoherNoise) ? "true" : "false")
                     << ", tileThresh=" << ((m_tileThresh) ? "true" : "false");
      if (m_tileThresh)
        msg(MSG::DEBUG) << ", thresh(hi,lo)=" << m_tileThreshHi << "," << m_tileThreshLo << endmsg;
      else
        msg(MSG::DEBUG) << endmsg;
    }
  }
 
  if (m_allChannels>1)
    ATH_MSG_DEBUG( "Create all channels with noise: true");
  else if (m_allChannels>0)
    ATH_MSG_DEBUG( "Create all channels without noise: true");
  else
    ATH_MSG_DEBUG( "Create all channels: false");
 
  if (m_calibRun) {
    m_filteredDigitsContainerKey = "";
  }
 
  if (!m_filteredDigitsContainerKey.key().empty()) {
    ATH_MSG_DEBUG( "Keep digits with hit energy above " << m_filterThreshold / MeV
                  << " MeV in " << m_filteredDigitsContainerKey.key() << " container");
    ATH_MSG_DEBUG( "Keep digits from MBTS with original G4 hit energy above "
                 << m_filterThresholdMBTS / MeV << " MeV ");
 
    ATH_CHECK( m_filteredDigitsContainerKey.initialize() );
 
  } else {
    m_filterThreshold = HUGE_VALL;
    m_filterThresholdMBTS = HUGE_VALL;
  }
 
  ATH_MSG_DEBUG( "nShapeHi=" << m_nShapeHi
                << " nBinsPerXHi=" << m_nBinsPerXHi
                << " timeStepHi=" << m_timeStepHi
                << " binTime0Hi=" << m_binTime0Hi);
 
  ATH_MSG_DEBUG( "nShapeLo=" << m_nShapeLo
                << " nBinsPerXLo=" << m_nBinsPerXLo
                << " timeStepLo=" << m_timeStepLo
                << " binTime0Lo=" << m_binTime0Lo);
 
  // decrease by 1, now they are indexes of last element in a vector
  --m_nShapeHi;
  --m_nShapeLo;
 
  /* ==================================*/
  // Store HWID's for all 12288 channels (48 channels in each of 64 drawers).
  IdContext drawer_context = m_tileHWID->drawer_context();
  int ndrawers = m_tileHWID->drawer_hash_max();
  const int nchMax = 48; // number of channels per drawer
 
  ATH_MSG_DEBUG( "ndrawers=" << ndrawers
                 << " nchMax=" << nchMax
                 << " HIGAIN=" << TileID::HIGHGAIN
                 << " LOWGAIN=" << TileID::LOWGAIN);
 
  /* Store all (12288) Identifiers for the calorimeter adc's for HIGHAIN */
  m_all_ids.reserve(ndrawers);
  for (int dr = 0; dr < ndrawers; ++dr) {
    HWIdentifier drawer_id;
    m_tileHWID->get_id(dr, drawer_id, &drawer_context);
 
    m_all_ids.push_back(std::make_unique<HWIdentifier[]>(nchMax));
    std::unique_ptr<HWIdentifier[]>& adc_ids = m_all_ids.back();
 
    int ros = m_tileHWID->ros(drawer_id);
    if (ros > 0) {
      int drawer = m_tileHWID->drawer(drawer_id);
      IdentifierHash idhash;
      m_tileHWID->get_hash(drawer_id, idhash, &drawer_context);
      int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
      if (drawerIdx != (int)idhash) {
        ATH_MSG_ERROR("drawer " << m_tileHWID->to_string(drawer_id, -2)
                       << " hash " << idhash << " NOT EQUAL to idx " << drawerIdx);
      } else if (msgLvl(MSG::VERBOSE) && m_cabling->connected(ros, drawer)) {
        msg(MSG::VERBOSE) << "drawer " << m_tileHWID->to_string(drawer_id, -2)
                          << " hash " << idhash << endmsg;
      }
 
      for (int ch = 0; ch < nchMax; ++ch) {
        adc_ids[ch] = m_tileHWID->adc_id(drawer_id, ch, TileID::HIGHGAIN);
      }
    }
  }
 
  ATH_CHECK( m_hitContainer_DigiHSTruthKey.initialize(m_doDigiTruth) );
  ATH_CHECK( m_digitsContainer_DigiHSTruthKey.initialize(m_doDigiTruth) );
 
  ATH_CHECK( m_hitContainerKey.initialize() );
  ATH_CHECK( m_digitsContainerKey.initialize() );
 
  ATH_MSG_DEBUG( "TileDigitsMaker initialization completed");
 
  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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  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.

overlayBackgroundDigits()

StatusCode TileDigitsMaker::overlayBackgroundDigits ( const TileDigitsCollection * bkgDigitCollection, const TileHitCollection * hitCollection, std::vector< std::vector< double > > & drawerBufferLo, std::vector< std::vector< double > > & drawerBufferHi, std::vector< int > & igain, int ros, int drawer, int drawerIdx, std::vector< int > & over_gain, const TileEMScale * emScale, const TileSampleNoise * sampleNoise, const TileDQstatus * dqStatus, const TileBadChannels * badChannels ) const

private

Definition at line 1246 of file TileDigitsMaker.cxx.

                                                                                              {
 
  if (hitCollection->identify() != bkgDigitCollection->identify()) {
    ATH_MSG_ERROR ( "Frag IDs for hit collection and digits overlay collection do not match "
                    << MSG::hex << hitCollection->identify() << " != " << bkgDigitCollection->identify()
                    << MSG::dec );
    return StatusCode::FAILURE;
  }
 
 
  // iterate over all digits in a collection
  for (const auto* bkgDigit : *bkgDigitCollection) {
 
    /* Get digit HWIdentifier (= adc_id) */
    HWIdentifier adcId = bkgDigit->adc_HWID();
    int channel = m_tileHWID->channel(adcId);
    int gain = m_tileHWID->adc(adcId);
 
    igain[channel] = gain;
 
    // get channel status
    bool good_dq = dqStatus->isAdcDQgood(ros, drawer, channel, gain);
    bool good_ch = (!badChannels->getAdcStatus(adcId).isBad());
 
    // get digits
    std::vector<float> digits = bkgDigit->samples();
    // get number of time samples & compare with nSamp
    int nSamp2 = digits.size();
    int goodDigits = nSamp2;
    float dig(m_f_ADCmaskValue),digmin(65536.),digmax(-65536.);
    if (goodDigits > 0) {
      auto minmax = std::minmax_element(digits.begin(), digits.end());
      digmin = *minmax.first;
      digmax = *minmax.second;
    }
 
    if (good_dq) {
      if (digmax > m_ADCmaxPlusEps) { // ignore everything in case of invalid digits
        dig = m_f_ADCmaskValue;
        goodDigits = 0;
      } else { // skip zeros or overflows
        float ADCmaxMinusEps = m_ADCmaxMinusEps;
        int badDigits = std::count_if(digits.begin(), digits.end(), [ADCmaxMinusEps](float dig){
                                                                      return (dig < 0.01) || (dig > ADCmaxMinusEps);});
        goodDigits -= badDigits;
        dig = digits.back();
      }
    } else if (goodDigits>0) {
      goodDigits = 0;
      dig = digits.back();
    }
 
    if (goodDigits>0) {
      over_gain[channel] = gain;
      if (nSamp2 != m_nSamples) {
        float lastDigit = digits.back();
        digits.resize(m_nSamples);
        // repeat last value in vector (nSamp-nSamp2) times
        std::fill(digits.begin() + nSamp2, digits.end(), lastDigit);
      }
 
      std::vector<double>& buffer = (gain == TileID::HIGHGAIN) ? drawerBufferHi[channel] : drawerBufferLo[channel];
      std::vector<double>& bufferLG = drawerBufferLo[channel];
 
      bool isFilledLG = false;
      if (gain == TileID::HIGHGAIN) {
        if (digmax - digmin > 5. && good_ch ) {// 5 ADC counts cut - to ignore pure noise in HG (less than 0.1 count effect in LG)
          float ratio = emScale->applyOnlineChargeCalibration(drawerIdx, channel, TileID::HIGHGAIN, 1.)
            / emScale->applyOnlineChargeCalibration(drawerIdx, channel, TileID::LOWGAIN, 1.); // ratio between low and high gain
 
          dig=std::min(digits[0],std::max(digmin, sampleNoise->getPed(drawerIdx, channel, TileID::HIGHGAIN)));
 
          std::transform(digits.begin(), digits.end(), bufferLG.begin(), [dig,ratio](float digit){return (digit - dig) * ratio;});
          isFilledLG = true;
        }
      }
 
      std::copy(digits.begin(), digits.end(), buffer.begin());
 
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << "RNDM BG ADC " << m_tileHWID->to_string(adcId)
                          << " samples=";
        for (int js = 0; js < m_nSamples; ++js)
          msg(MSG::VERBOSE) << " " << buffer[js];
        if (!good_ch)
          msg(MSG::VERBOSE) << " BCH";
        // good_dq should always be true here, but leave in place in case
        // things change.
        //coverity[DEADCODE]
        if (!good_dq) {
          msg(MSG::VERBOSE) << " BDQ";
        } else if (isFilledLG) {
          msg(MSG::VERBOSE) << "  LG=";
          for (int js = 0; js < m_nSamples; ++js)
            msg(MSG::VERBOSE) << " " << int(bufferLG[js]*100)/100.;
        }
        msg(MSG::VERBOSE) << endmsg;
      }
 
    } else if (nSamp2 > 0) {
      over_gain[channel] = 10+gain; // flag problematic channel
 
      std::vector<double>& buffer = (gain == TileID::HIGHGAIN) ? drawerBufferHi[channel] : drawerBufferLo[channel];
 
      if (digmin != digmax || (dig!=0. && dig!=m_f_ADCmax)) {
        dig = m_f_ADCmaskValue; // keep only 0 or m_f_ADCmax as it is
      }
      std::fill(buffer.begin(), buffer.end(), dig);
 
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << "BAD BG  ADC " << m_tileHWID->to_string(adcId)
                          << " samples=";
        for (int js = 0; js < nSamp2; ++js)
          msg(MSG::VERBOSE) << " " << digits[js];
        msg(MSG::VERBOSE) << ((good_ch)?"":" BCH") << ((good_dq)?"":" BDQ") << endmsg;
      }
 
    } else {
      ATH_MSG_VERBOSE( "NO BG   ADC " << m_tileHWID->to_string(adcId)
                       << " samples= 0 0 0 0 0 0 0"
                       << ((good_ch)?"":" BCH") << ((good_dq)?"":" BDQ") );
    }
  }
  return StatusCode::SUCCESS;
}

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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_ADCmaxMinusEps

float TileDigitsMaker::m_ADCmaxMinusEps {0.0F}

private

ADC saturation value - 0.01 or something small.

Definition at line 175 of file TileDigitsMaker.h.

{0.0F}; 

m_ADCmaxPlusEps

float TileDigitsMaker::m_ADCmaxPlusEps {0.0F}

private

ADC saturation value + 0.01 or something small.

Definition at line 176 of file TileDigitsMaker.h.

{0.0F};  

m_all_ids

std::vector<std::unique_ptr<HWIdentifier[]> > TileDigitsMaker::m_all_ids

private

Definition at line 168 of file TileDigitsMaker.h.

m_allChannels

Gaudi::Property<int> TileDigitsMaker::m_allChannels

private

Initial value:

{this,
         "AllChannels", -1, "Create all channels, use 0 or 1 or 2 (default=-1 - unset)"}

Definition at line 157 of file TileDigitsMaker.h.

                                    {this,
         "AllChannels", -1, "Create all channels, use 0 or 1 or 2 (default=-1 - unset)"};

m_badChannelsKey

SG::ReadCondHandleKey<TileBadChannels> TileDigitsMaker::m_badChannelsKey

private

Initial value:

{this,
        "TileBadChannels", "TileBadChannels", "Input Tile bad channel status"}

Name of TileBadChannels in condition store.

Definition at line 233 of file TileDigitsMaker.h.

                                                         {this,
        "TileBadChannels", "TileBadChannels", "Input Tile bad channel status"};

m_binTime0Hi

int TileDigitsMaker::m_binTime0Hi {0}

private

Index of time=0 bin for high gain pulse shape.

Definition at line 187 of file TileDigitsMaker.h.

{0};                

m_binTime0Lo

int TileDigitsMaker::m_binTime0Lo {0}

private

Index of time=0 bin for low gain pulse shape.

Definition at line 193 of file TileDigitsMaker.h.

{0};                

m_cabling

const TileCablingService* TileDigitsMaker::m_cabling {nullptr}

private

TileCabling instance.

Definition at line 166 of file TileDigitsMaker.h.

{nullptr}; 

m_cablingSvc

ServiceHandle<TileCablingSvc> TileDigitsMaker::m_cablingSvc

private

Initial value:

{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Name of Tile cabling service.

Definition at line 199 of file TileDigitsMaker.h.

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

m_calibRun

Gaudi::Property<bool> TileDigitsMaker::m_calibRun

private

Initial value:

{this,
         "CalibrationRun", false, "If true -> both high and low gain saved"}

Definition at line 142 of file TileDigitsMaker.h.

                                  {this,
         "CalibrationRun", false, "If true -> both high and low gain saved"};

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_digitsContainer_DigiHSTruthKey

SG::WriteHandleKey<TileDigitsContainer> TileDigitsMaker::m_digitsContainer_DigiHSTruthKey

private

Initial value:

{this,
        "TileDigitsContainer_DigiHSTruth", "TileDigitsCnt_DigiHSTruth", "Output DigiHSTruth Tile digits container key"}

Definition at line 124 of file TileDigitsMaker.h.

                                                                          {this,
        "TileDigitsContainer_DigiHSTruth", "TileDigitsCnt_DigiHSTruth", "Output DigiHSTruth Tile digits container key"};

m_digitsContainerKey

SG::WriteHandleKey<TileDigitsContainer> TileDigitsMaker::m_digitsContainerKey

private

Initial value:

{this,
        "TileDigitsContainer", "TileDigitsCnt", "Output Tile digits container key"}

Definition at line 121 of file TileDigitsMaker.h.

                                                              {this,
        "TileDigitsContainer", "TileDigitsCnt", "Output Tile digits container key"};

m_digitShapeHi

std::vector<double> TileDigitsMaker::m_digitShapeHi

private

High gain pulse shape.

Definition at line 184 of file TileDigitsMaker.h.

m_digitShapeLo

std::vector<double> TileDigitsMaker::m_digitShapeLo

private

Low gain pulse shape.

Definition at line 190 of file TileDigitsMaker.h.

m_doDigiTruth

Gaudi::Property<bool> TileDigitsMaker::m_doDigiTruth

private

Initial value:

{this,
         "DoHSTruthReconstruction", false, ""}

Definition at line 154 of file TileDigitsMaker.h.

                                     {this,
         "DoHSTruthReconstruction", false, ""};

m_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileDigitsMaker::m_DQstatusKey

private

Initial value:

{this,
        "TileDQstatus", "", "Input TileDQstatus key" }

Definition at line 236 of file TileDigitsMaker.h.

                                                {this,
        "TileDQstatus", "", "Input TileDQstatus key" };

m_emScaleKey

SG::ReadCondHandleKey<TileEMScale> TileDigitsMaker::m_emScaleKey

private

Initial value:

{this,
        "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"}

Name of TileEMScale in condition store.

Definition at line 215 of file TileDigitsMaker.h.

                                                 {this,
        "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"};

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_f_ADCmaskValue

float TileDigitsMaker::m_f_ADCmaskValue {0.0F}

private

indicates channels which were masked in background dataset

Definition at line 177 of file TileDigitsMaker.h.

{0.0F}; 

m_f_ADCmax

float TileDigitsMaker::m_f_ADCmax {0.0F}

private

ADC saturation value.

Definition at line 173 of file TileDigitsMaker.h.

{0.0F};       

m_f_ADCmaxHG

float TileDigitsMaker::m_f_ADCmaxHG {0.0F}

private

ADC saturation value - 0.5.

Definition at line 174 of file TileDigitsMaker.h.

{0.0F};     

m_filteredDigitsContainerKey

SG::WriteHandleKey<TileDigitsContainer> TileDigitsMaker::m_filteredDigitsContainerKey

private

Initial value:

{this,
         "TileFilteredContainer", "TileDigitsFlt", "Output filtered Tile digits container key"}

Definition at line 127 of file TileDigitsMaker.h.

                                                                      {this,
         "TileFilteredContainer", "TileDigitsFlt", "Output filtered Tile digits container key"};

m_filterThreshold

Gaudi::Property<double> TileDigitsMaker::m_filterThreshold

private

Initial value:

{this,
         "FilterThreshold", 100.0 * Athena::Units::MeV, "Threshold on filtered digits (default - 100 MeV)"}

Definition at line 130 of file TileDigitsMaker.h.

                                           {this,
         "FilterThreshold", 100.0 * Athena::Units::MeV, "Threshold on filtered digits (default - 100 MeV)"};

m_filterThresholdMBTS

Gaudi::Property<double> TileDigitsMaker::m_filterThresholdMBTS

private

Initial value:

{this,
         "FilterThresholdMBTS", 0.0 * Athena::Units::MeV, "Threshold on filtered digits of MBTS (default - 0 MeV)"}

Definition at line 133 of file TileDigitsMaker.h.

                                               {this,
         "FilterThresholdMBTS", 0.0 * Athena::Units::MeV, "Threshold on filtered digits of MBTS (default - 0 MeV)"};

m_hitContainer_DigiHSTruthKey

SG::ReadHandleKey<TileHitContainer> TileDigitsMaker::m_hitContainer_DigiHSTruthKey

private

Initial value:

{this,
         "TileHitContainer_DigiHSTruth","TileHitCnt_DigiHSTruth", "input Tile hit container key"}

Definition at line 112 of file TileDigitsMaker.h.

                                                                   {this,
         "TileHitContainer_DigiHSTruth","TileHitCnt_DigiHSTruth", "input Tile hit container key"};

m_hitContainerKey

SG::ReadHandleKey<TileHitContainer> TileDigitsMaker::m_hitContainerKey

private

Initial value:

{this,
         "TileHitContainer", "TileHitCnt", "input Tile hit container key"}

Definition at line 109 of file TileDigitsMaker.h.

                                                       {this,
         "TileHitContainer", "TileHitCnt", "input Tile hit container key"};

m_i_ADCmax

int TileDigitsMaker::m_i_ADCmax {0}

private

ADC saturation value.

Definition at line 172 of file TileDigitsMaker.h.

{0};            

m_infoName

Gaudi::Property<std::string> TileDigitsMaker::m_infoName

private

Initial value:

{this,
         "TileInfoName", "TileInfo", "TileInfo object name"}

Definition at line 136 of file TileDigitsMaker.h.

                                       {this,
         "TileInfoName", "TileInfo", "TileInfo object name"};

m_inputDigitContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileDigitsMaker::m_inputDigitContainerKey {this, "InputTileDigitContainer","",""}

private

Definition at line 118 of file TileDigitsMaker.h.

{this, "InputTileDigitContainer","",""};

m_inputDigitContainerName

std::string TileDigitsMaker::m_inputDigitContainerName {""}

private

Definition at line 119 of file TileDigitsMaker.h.

{""};

m_integerDigits

Gaudi::Property<bool> TileDigitsMaker::m_integerDigits

private

Initial value:

{this,
         "IntegerDigits", true, "Round digits to integer"}

Definition at line 139 of file TileDigitsMaker.h.

                                       {this,
         "IntegerDigits", true, "Round digits to integer"};

m_iTrig

int TileDigitsMaker::m_iTrig {0}

private

Index of the triggering time slice.

Definition at line 171 of file TileDigitsMaker.h.

{0};               

m_maskBadChannels

Gaudi::Property<bool> TileDigitsMaker::m_maskBadChannels

private

Initial value:

{this,
         "MaskBadChannels", false, "Remove channels tagged bad (default=false)"}

Definition at line 151 of file TileDigitsMaker.h.

                                         {this,
         "MaskBadChannels", false, "Remove channels tagged bad (default=false)"};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> TileDigitsMaker::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc"}

private

Definition at line 160 of file TileDigitsMaker.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc"};

m_nBinsPerXHi

int TileDigitsMaker::m_nBinsPerXHi {0}

private

Number of bins per bunch crossing in high gain pulse shape.

Definition at line 186 of file TileDigitsMaker.h.

{0};               

m_nBinsPerXLo

int TileDigitsMaker::m_nBinsPerXLo {0}

private

Number of bins per bunch crossing in low gain pulse shape.

Definition at line 192 of file TileDigitsMaker.h.

{0};               

m_nSamples

int TileDigitsMaker::m_nSamples {0}

private

Number of time slices for each channel.

Definition at line 170 of file TileDigitsMaker.h.

{0};            

m_nShapeHi

int TileDigitsMaker::m_nShapeHi {0}

private

Number of bins in high gain pulse shape.

Definition at line 185 of file TileDigitsMaker.h.

{0};                  

m_nShapeLo

int TileDigitsMaker::m_nShapeLo {0}

private

Number of bins in low gain pulse shape.

Definition at line 191 of file TileDigitsMaker.h.

{0};                  

m_onlyUseContainerName

Gaudi::Property<bool> TileDigitsMaker::m_onlyUseContainerName

private

Initial value:

{this,
        "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}

Definition at line 115 of file TileDigitsMaker.h.

                                              {this,
        "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."};

m_pulseShapeKey

SG::ReadCondHandleKey<TilePulse> TileDigitsMaker::m_pulseShapeKey

private

Initial value:

{this,
        "TilePulseShape", "TilePulseShape", "Input Tile pulse shape"}

Name of TilePulseShape in condition store.

Definition at line 221 of file TileDigitsMaker.h.

                                                  {this,
        "TilePulseShape", "TilePulseShape", "Input Tile pulse shape"};

m_randomStreamName

Gaudi::Property<std::string> TileDigitsMaker::m_randomStreamName {this, "RandomStreamName", "Tile_DigitsMaker", ""}

private

Random Stream Name.

Definition at line 204 of file TileDigitsMaker.h.

{this, "RandomStreamName", "Tile_DigitsMaker", ""};

m_rndmEvtOverlay

Gaudi::Property<bool> TileDigitsMaker::m_rndmEvtOverlay

private

Initial value:

{this,
         "RndmEvtOverlay", false, "Pileup and/or noise added by overlaying random events (default=false)"}

Definition at line 145 of file TileDigitsMaker.h.

                                        {this,
         "RndmEvtOverlay", false, "Pileup and/or noise added by overlaying random events (default=false)"};

m_rndmSvc

ServiceHandle<IAthRNGSvc> TileDigitsMaker::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Random number service to use.

Definition at line 202 of file TileDigitsMaker.h.

{this, "RndmSvc", "AthRNGSvc", ""};  

m_sampleNoiseKey

SG::ReadCondHandleKey<TileSampleNoise> TileDigitsMaker::m_sampleNoiseKey

private

Initial value:

{this,
        "TileSampleNoise", "TileSampleNoise", "Input Tile sample noise"}

Name of TileSampleNoise in condition store.

Definition at line 209 of file TileDigitsMaker.h.

                                                         {this,
        "TileSampleNoise", "TileSampleNoise", "Input Tile sample noise"};

m_samplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> TileDigitsMaker::m_samplingFractionKey

private

Initial value:

{this,
        "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"}

Name of TileSamplingFraction in condition store.

Definition at line 227 of file TileDigitsMaker.h.

                                                                   {this,
        "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};

m_tileCoherNoise

bool TileDigitsMaker::m_tileCoherNoise {false}

private

If true => generate coherent noise in TileDigits.

Definition at line 179 of file TileDigitsMaker.h.

{false}; 

m_tileHWID

const TileHWID* TileDigitsMaker::m_tileHWID {nullptr}

private

Definition at line 164 of file TileDigitsMaker.h.

{nullptr};

m_tileID

const TileID* TileDigitsMaker::m_tileID {nullptr}

private

Definition at line 162 of file TileDigitsMaker.h.

{nullptr};

m_tileInfo

const TileInfo* TileDigitsMaker::m_tileInfo {nullptr}

private

Definition at line 165 of file TileDigitsMaker.h.

{nullptr};

m_tileNoise

bool TileDigitsMaker::m_tileNoise {false}

private

If true => generate noise in TileDigits.

Definition at line 178 of file TileDigitsMaker.h.

{false};      

m_tileTBID

const TileTBID* TileDigitsMaker::m_tileTBID {nullptr}

private

Definition at line 163 of file TileDigitsMaker.h.

{nullptr};

m_tileThresh

bool TileDigitsMaker::m_tileThresh {false}

private

If true => apply threshold to Digits.

Definition at line 180 of file TileDigitsMaker.h.

{false};     

m_tileThreshHi

double TileDigitsMaker::m_tileThreshHi {0.0}

private

Actual threshold value for high gain.

Definition at line 181 of file TileDigitsMaker.h.

{0.0};   

m_tileThreshLo

double TileDigitsMaker::m_tileThreshLo {0.0}

private

Actual threshold value for low gain.

Definition at line 182 of file TileDigitsMaker.h.

{0.0};   

m_timeStepHi

double TileDigitsMaker::m_timeStepHi {0.}

private

Time step in high gain pulse shape: 25.0 / nBinsPerXHi.

Definition at line 188 of file TileDigitsMaker.h.

{0.};            

m_timeStepLo

double TileDigitsMaker::m_timeStepLo {0.}

private

Time step in low gain pulse shape: 25.0 / nBinsPerXLo.

Definition at line 194 of file TileDigitsMaker.h.

{0.};            

m_useCoolPulseShapes

Gaudi::Property<bool> TileDigitsMaker::m_useCoolPulseShapes

private

Initial value:

{this,
         "UseCoolPulseShapes", true, "Pulse shapes from database (default=true)"}

Definition at line 148 of file TileDigitsMaker.h.

                                            {this,
         "UseCoolPulseShapes", true, "Pulse shapes from database (default=true)"};

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.

---

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

• TileDigitsMaker.h
• TileDigitsMaker.cxx