TileHitToTTL1 Class Reference

This algorithm builds TileTTL1 objects from TileHits. More...

#include <TileHitToTTL1.h>

Inheritance diagram for TileHitToTTL1:

Public Member Functions
virtual	~TileHitToTTL1 ()=default
	Destructor.
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_maskBadChannels
Gaudi::Property< std::string >	m_infoName
Gaudi::Property< std::string >	m_TileTTL1Type
SG::ReadHandleKey< TileHitContainer >	m_hitContainerKey
SG::WriteHandleKey< TileTTL1Container >	m_ttl1ContainerKey
SG::WriteHandleKey< TileTTL1Container >	m_mbtsTTL1ContainerKey
SG::ReadCondHandleKey< TileSamplingFraction >	m_samplingFractionKey
	Name of TileSamplingFraction in condition store.
bool	m_cosmicsType {false}
	if true => use dediated cosmcis TTL1
const TileID *	m_tileID {nullptr}
	Pointer to TileID helper.
const TileTBID *	m_tileTBID {nullptr}
	Pointer to TileID helper.
const TileHWID *	m_tileHWID {nullptr}
	Pointer to TileHWID helper.
const TileInfo *	m_tileInfo {nullptr}
	Pointer to TileInfo.
const CaloLVL1_ID *	m_TT_ID {nullptr}
	Pointer to TT Identifier.
const TileCablingService *	m_cabling {nullptr}
	Pointer to the TileCablingService instance.
int	m_nSamples {0}
	number of time slices for each channel
int	m_iTrig {0}
	index of the triggering time slice
int	m_MBTSnSamples {0}
	number of time slices for each chan for MBTS TTL1
int	m_MBTSiTrig {0}
	index of the triggering time slice for MBTS TTL1
int	m_lastTower {15}
	total number of towers in TileCal
bool	m_tileNoise {false}
	If true => generate noise for the TileTTL1 creation.
bool	m_tileThresh {false}
	If true => apply threshold on the conversion to TileTTL1.
ServiceHandle< TileCablingSvc >	m_cablingSvc
	Name of Tile cabling service.
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number generator engine to use.
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Tile_HitToTTL1", ""}
	Random Stream Name.
SG::ReadCondHandleKey< TileEMScale >	m_emScaleKey
	Name of TileEMScale in condition store.
SG::ReadCondHandleKey< TileBadChannels >	m_badChannelsKey
	Name of TileBadChannels in condition store.
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 builds TileTTL1 objects from TileHits.

It simulates the Tile Level 1 Trigger Towers (TTL1), which are hardware sums of the Tile channels, with about 5 channels per tower. The towers are read out in N time slices, with N=7 as a default. The default running mode is 'standard' which produces N read out slices The 'cosmics' running mode is also possible which stores only the peak value of the pulse (this mode is used to simulate the Tile cosmics boards used during pre-beam commissioning). Noise can be added to every sample and threshold can be applied. Dead/half-gain PMTs are also accounted for in this algorithm.

Definition at line 72 of file TileHitToTTL1.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

~TileHitToTTL1()

virtual TileHitToTTL1::~TileHitToTTL1 ( )

virtualdefault

Destructor.

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

overridevirtual

execute method

Definition at line 177 of file TileHitToTTL1.cxx.

                                                               {
 
  ATH_MSG_DEBUG( "Executing TileHitToTTL1" );
 
  // declare array for random number generation for noise in samples.
  double Rndm[16];      // Can't use variable size array
 
  // Prepare RNG Service
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName, ctx );
 
  SG::ReadCondHandle<TileEMScale> emScale(m_emScaleKey, ctx);
  ATH_CHECK( emScale.isValid() );
 
  const TileBadChannels* badChannels = nullptr;
  if (m_maskBadChannels) {
    SG::ReadCondHandle<TileBadChannels> badChannelsHandle(m_badChannelsKey, ctx);
    ATH_CHECK( badChannelsHandle.isValid() );
    badChannels = *badChannelsHandle;
  }
 
  /*........................................................................*/
  // Get hit container from TES and create TTL1 and MBTS container
  // Note that hit container has 256 collections (one for each drawer),
  // but TTL1 container has no collections and no structure
  /*........................................................................*/
 
  SG::ReadHandle<TileHitContainer> hitContainer(m_hitContainerKey, ctx);
  ATH_CHECK( hitContainer.isValid() );
 
  SG::WriteHandle<TileTTL1Container> ttl1Container(m_ttl1ContainerKey, ctx);
  // Register the TTL1 container in the TES
  ATH_CHECK( ttl1Container.record(std::make_unique<TileTTL1Container>()) );
  ATH_MSG_DEBUG( "TileTTL1Container registered successfully (" << m_ttl1ContainerKey.key() << ")" );
 
  std::unique_ptr<TileTTL1Container>  mbtsTTL1Container;
  if (!m_mbtsTTL1ContainerKey.key().empty()) {
    mbtsTTL1Container = std::make_unique<TileTTL1Container>();
  }
 
  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
  ATH_CHECK( samplingFraction.isValid() );
 
  /*........................................................................*/
  // Create temporary arrays for processing signals.
  // Create array for all TT amplitudes in a single drawer
  /*........................................................................*/
  Identifier ttId[16]; // array of TT identifiers in a single drawer
  std::vector<double> ttAmp[16]; // array of all TT amplitudes in a single drawer
  std::vector<double> MBTSAmp; // MBTS amplitudes in a single drawer
  bool ttHit[16];      // array of TT occupancy in a single drawer
  bool MBTSHit;        // MBTS occupancy in a single drawer
  int nTT;             // number of hit towers in this drawer.
  int nHit;            // number of hits in this drawer.
  int nIgnore;         // number of ignored hits in this drawer.
  int nTTTot = 0;        // total number of hit towers.
  int nHitTot = 0;       // total number of hits.
  int nIgnoreTot = 0;    // total number of ignored hits.
  double ttAmpTot = 0;   // total energy in good level-1 towers.
  double ttAmpTotIg = 0.;   // total energy in "ignored" level-1 towers.
  int minieta, maxieta, posneg;
 
  for (int ieta = 0; ieta < 16; ++ieta)
    ttAmp[ieta].resize(m_nSamples);
  MBTSAmp.resize(m_MBTSnSamples);
 
  // temporary array to make sub of all subhits in one channel 
  std::vector<double> hitSamples(m_nSamples);
 
  // Create array for the nSamples time-samples of a single tower.
  // If running the Cosmics configuration, put out only the peak value
  std::vector<float> ttL1samples;
  std::vector<float> MBTSsamples;
  if (m_cosmicsType) ttL1samples.resize(1);
  else ttL1samples.resize(m_nSamples);
  MBTSsamples.resize(m_MBTSnSamples);
 
  std::vector<double> ttl1Shape(m_nSamples, 0.);
  std::vector<double> ttl1MBTSShape(m_MBTSnSamples, 0.);
  /*........................................................................*/
  // Begin loop over all collections (collection = electronic drawer). 
  /*........................................................................*/
 
  for (const TileHitCollection* hitCollection : *hitContainer) {
 
    // get drawer and ros number
    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);
 
    // check that this drawer is connected, if not skip it
    if (m_cosmicsType || m_cabling->connected(ros, drawer)) {
      ATH_MSG_VERBOSE( "ROS " << ros
                      << " drawer " << drawer
                      << " is connected");
    } else {
      continue;
    }
 
    // Find the partition for this drawer
    // Also set the min and max eta range for the towers in this partition
    switch (ros) {
      case TileHWID::BARREL_POS:
        posneg = +1;
        minieta = 0;
        maxieta = 8;
        break;
      case TileHWID::BARREL_NEG:
        posneg = -1;
        minieta = 0;
        maxieta = 8;
        break;
      case TileHWID::EXTBAR_POS:
        posneg = +1;
        minieta = 9;
        maxieta = m_lastTower;
        break;
      case TileHWID::EXTBAR_NEG:
        posneg = -1;
        minieta = 9;
        maxieta = m_lastTower;
        break;
      default:
        posneg = minieta = maxieta = 0;
        break;
    }
 
    // Zero temporary array of trigger tower amplitudes (TTL1amp) for this collection
    for (int ieta = 0; ieta < 16; ++ieta) {
      for (int js = 0; js < m_nSamples; ++js)
        ttAmp[ieta][js] = 0.0;
    }
    for (int js = 0; js < m_MBTSnSamples; ++js)
      MBTSAmp[js] = 0.0;
 
    MBTSHit = false;
    memset(ttHit, 0, sizeof(ttHit));
    nTT = nIgnore = nHit = 0;
 
    /*........................................................................*/
    // Iterate over all hits in this collection, summing amps for each tower.
    /*........................................................................*/
    for (const TileHit* tile_hit : *hitCollection) {
 
      // Get hit Identifier (= pmt_id)
      Identifier pmt_id = tile_hit->pmt_ID();
      // Get hit HWIdentifier (= channel_id)
      HWIdentifier pmt_HWid = tile_hit->pmt_HWID();
      // Get channel and ADC number
      int channel = m_tileHWID->channel(pmt_HWid);
 
      // conversion to hit energy after EMscale correction 
      double hit_calib = samplingFraction->getSamplingFraction(drawerIdx, channel);
      hit_calib = std::round(hit_calib * 1000) / 1000;
      // conversion to charge measured by digitizer
      // The trigger always uses the low gain
      double qfactor = hit_calib / emScale->calibrateChannel(drawerIdx, channel
                                                             , TileID::LOWGAIN, 1.
                                                             , TileRawChannelUnit::PicoCoulombs
                                                             , TileRawChannelUnit::MegaElectronVolts);
 
      // determine if the channel is good from the channel status DB
      bool is_good = true;
      if (m_maskBadChannels) {
        HWIdentifier adc_id = m_tileHWID->adc_id(pmt_HWid, TileID::LOWGAIN);
        TileBchStatus status = badChannels->getAdcStatus(adc_id);
 
        // if channel is bad, set qfactor to zero
        if (status.isNoGainL1()) {
          is_good = false;
          qfactor = 0.0;
        }
 
        // check if channel is half gain, scale the qfactor by 50%
        if (status.isHalfGainL1()) {
          is_good = false;
          qfactor *= 0.5;
        }
 
      } // end of bad channel status
 
      // Treat signal from MBTS differently
      if (m_tileTBID->is_tiletb(pmt_id)) {
 
        if (mbtsTTL1Container) {
 
          // Loop over the subhits for this channel.  For each one,
          // convolute with shaping function and add to digitSamples.
          for (int js = 0; js < m_MBTSnSamples; ++js)
            hitSamples[js] = 0.0;
 
          int n_hits = tile_hit->size();
          for (int ihit = 0; ihit < n_hits; ++ihit) {
            // Need to pass the negative of t_hit, this is because ttl1Shape returns the amplitude at 
            // a given phase, whereas the t_hit from t=0 when the hit took place
            double t_hit = -(tile_hit->time(ihit));
            m_tileInfo->ttl1Shape(m_MBTSnSamples, m_MBTSiTrig, t_hit, ttl1MBTSShape);
 
            double e_hit = tile_hit->energy(ihit);
            for (int js = 0; js < m_MBTSnSamples; ++js) {
              hitSamples[js] += e_hit * ttl1MBTSShape[js];
            } // end of loop over MBTS samples
          }  // end loop over sub-hits 
 
          if (MBTSHit) {
            for (int js = 0; js < m_MBTSnSamples; ++js)
              MBTSAmp[js] += qfactor * hitSamples[js];
 
          } else {
            MBTSHit = true;
            for (int js = 0; js < m_MBTSnSamples; ++js)
              MBTSAmp[js] = qfactor * hitSamples[js];
          }
 
          if (msgLvl(MSG::VERBOSE)) {
 
            // Diagnostic checks
            int side = m_tileTBID->type(pmt_id);
            int phi = m_tileTBID->module(pmt_id);
            int eta = m_tileTBID->channel(pmt_id);
            int channel = m_tileHWID->channel(pmt_HWid);
 
            msg(MSG::VERBOSE) << "New MBTS Hit:"
                              << " ros=" << ros
                              << ", drawer=" << drawer
                              << ", ch=" << channel
                              << ", side=" << side
                              << ", phi=" << phi
                              << ", eta=" << eta
                              << ", e0=" << hitSamples[m_MBTSiTrig] * hit_calib
                              << ", chan is good=" << is_good << endmsg;
          }
        }
        continue;
      } // end of MBTS loop
 
      // Get TT Identifier for this pmt 
      Identifier tt_id = tile_hit->tt_ID();
 
      // Get eta-phi indices of TTL1 for this channel.
      int ieta = m_TT_ID->eta(tt_id);
      int iphi = m_TT_ID->phi(tt_id); // (same as module number).
      if (iphi != drawer && m_tileID->sample(pmt_id) != TileID::SAMP_E)
        ATH_MSG_ERROR( "drawer=" << drawer << ", iphi=" << iphi );
 
      // Loop over the subhits for this channel.  For each one,
      // convolute with shaping function and add to digitSamples.
      for (int js = 0; js < m_nSamples; ++js)
        hitSamples[js] = 0.0;
      int n_hits = tile_hit->size();
      for (int ihit = 0; ihit < n_hits; ++ihit) {
        // Need to pass the negative of t_hit, this is because ttl1Shape returns the amplitude at 
        // a given phase, whereas the t_hit from t=0 when the hit took place
        double t_hit = -(tile_hit->time(ihit));
        m_tileInfo->ttl1Shape(m_nSamples, m_iTrig, t_hit, ttl1Shape);
 
        double e_hit = tile_hit->energy(ihit);
        for (int js = 0; js < m_nSamples; ++js) {
          hitSamples[js] += e_hit * ttl1Shape[js];
        } // end of loop over samples
      } // end loop over sub-hits
 
      // check if TT already exists, if so just add energy
      if (ttHit[ieta]) {
        for (int js = 0; js < m_nSamples; ++js)
          ttAmp[ieta][js] += qfactor * hitSamples[js];
 
        // if not create new TT
      } else {
        ttId[ieta] = tt_id;
        ttHit[ieta] = true;
        for (int js = 0; js < m_nSamples; ++js)
          ttAmp[ieta][js] = qfactor * hitSamples[js];
 
        if (ieta >= minieta && ieta <= maxieta)
          ++nTT; // count only valid TT
      }
      ++nHit;
      if (ieta < minieta || ieta > maxieta || !is_good)
        ++nIgnore;
 
      //Sum cell energy for comparison to other algos.
      if (ieta >= minieta && ieta <= maxieta && is_good) {
        ttAmpTot += hitSamples[m_iTrig] * hit_calib;
      } else {
        ttAmpTotIg += hitSamples[m_iTrig] * hit_calib;
      }
 
      if (msgLvl(MSG::VERBOSE)) {
 
        // Diagnostic checks:
        int side = m_tileID->side(pmt_id);
        int tower = m_tileID->tower(pmt_id);
        int sample = m_tileID->sample(pmt_id);
        int pmt = m_tileID->pmt(pmt_id);
        int channel = m_tileHWID->channel(pmt_HWid);
 
        msg(MSG::VERBOSE) << "New Hit:"
                          << " ros=" << ros
                          << ", drawer=" << drawer
                          << ", ch=" << channel
                          << ", side=" << side
                          << ", tower=" << tower
                          << ", sample=" << sample
                          << ", pmt=" << pmt
                          << ", e0=" << hitSamples[m_iTrig] * hit_calib
                          << ", ie=" << ieta
                          << ", ip=" << iphi
                          << ", chan is good= " << is_good;
 
        if (ieta >= minieta && ieta <= maxieta)
          msg(MSG::VERBOSE) << endmsg;
        else
          msg(MSG::VERBOSE) << " Outside limits" << endmsg;
      } // end of verbose printing 
 
    } // end loop over hits in this drawer.
 
    nTTTot += nTT;
    nHitTot += nHit;
    nIgnoreTot += nIgnore;
 
    ATH_MSG_VERBOSE( "      Statistics for"
                    << " ROS=" << ros
                    << ", drawer=" << drawer
                    << ";  posneg=" << posneg
                    << ", minieta=" << minieta
                    << ", maxieta=" << maxieta
                    << ";  nTT=" << nTT
                    << ", nHit=" << nHit
                    << ", nIgnore=" << nIgnore );
 
 
    /*........................................................................*/
    // We now have all the TTL1 amplitudes for this drawer.  
    // Loop over towers to produce the electronics signals (= time samples).
    // If tileNoise is requested, generate random numbers to give noise
    // For Cosmics configuration, only calculate peak value.
    // (no ADC on Chicago custom board, only discriminator)
    /*........................................................................*/
 
    if (mbtsTTL1Container) {
      Identifier MBTS_id = m_cabling->drawer2MBTS_id(drawer_id);
      if (MBTS_id.is_valid()) {
        bool Good = m_tileNoise || MBTSHit;
        if (Good) {
          double ttL1NoiseSigma = m_tileInfo->MBTSL1NoiseSigma(MBTS_id);
          double ttL1Thresh = m_tileInfo->MBTSL1Thresh(MBTS_id);
          double ttL1Ped = m_tileInfo->MBTSL1Ped(MBTS_id);
          double ttL1Calib = m_tileInfo->MBTSL1Calib(MBTS_id);
          double ttL1Max = m_tileInfo->MBTSL1Max(MBTS_id);
 
          if (m_tileNoise)
            RandGaussQ::shootArray(rngWrapper->getEngine(ctx), m_MBTSnSamples, Rndm);
          for (int jsamp = 0; jsamp < m_MBTSnSamples; ++jsamp) {
            MBTSAmp[jsamp] *= ttL1Calib; // convert pCb to mV
            MBTSsamples[jsamp] = MBTSAmp[jsamp] + ttL1Ped;
            if (m_tileNoise)
              MBTSsamples[jsamp] += ttL1NoiseSigma * Rndm[jsamp];
 
            // check if the voltage is above the saturation point,
            // if so, set the pulse value to the saturation point
            if (MBTSsamples[jsamp] > ttL1Max)
              MBTSsamples[jsamp] = ttL1Max;
 
          }  // end loop over samples
 
          if (m_tileThresh)
            if (MBTSsamples[m_MBTSiTrig] - ttL1Ped < ttL1Thresh)
              Good = false;
 
          if (Good) {
            std::unique_ptr<TileTTL1> mbtsTTL1 = std::make_unique<TileTTL1>(MBTS_id, MBTSsamples);
            mbtsTTL1Container->push_back(mbtsTTL1.release());
            ATH_MSG_DEBUG( "mbtsTTL1 saved. Is MBTS hit " << MBTSHit
                          << " Is noise " << m_tileNoise );
          }
        }
      }
    }
 
    for (int ieta = minieta; ieta <= maxieta; ++ieta) {
      int iphi = drawer;
      bool Good = m_tileNoise || ttHit[ieta];
      if (Good) {
        if (!ttHit[ieta])
          ttId[ieta] = m_TT_ID->tower_id(posneg, 1, 0, ieta, drawer);
 
        /* Include shaping fuction, pedestal, and noise. */
 
        // Chicago cosmic Trigger board
        if (m_cosmicsType) {
          double ttL1NoiseSigma = m_tileInfo->TTL1CosmicsNoiseSigma(ttId[ieta]);
          double ttL1Thresh = m_tileInfo->TTL1CosmicsThresh(ttId[ieta]);
          double ttL1Ped = m_tileInfo->TTL1CosmicsPed(ttId[ieta]);
          double ttL1Calib = m_tileInfo->TTL1CosmicsCalib(ttId[ieta]);
 
          double peakAmp = 0.0;
          int peakSamp = 0;
          for (int jsamp = 0; jsamp < m_nSamples; ++jsamp) {
            ttAmp[ieta][jsamp] *= ttL1Calib; // convert pCb to mV
            ttAmp[ieta][jsamp] += ttL1Ped;
            if (ttAmp[ieta][jsamp] > peakAmp) {
              peakAmp = ttAmp[ieta][jsamp];
              peakSamp = jsamp;
            }
          }  // end loop over samples
 
          if (m_tileNoise)
            peakAmp += ttL1NoiseSigma * RandGaussQ::shoot(rngWrapper->getEngine(ctx));
          ttL1samples[0] = peakAmp;
          if (m_tileThresh) {
            if (ttL1samples[0] - ttL1Ped < ttL1Thresh)
              Good = false;
          }
          if (msgLvl(MSG::DEBUG) && Good) {
            msg(MSG::DEBUG) << " TTL1:  "
                            << " ros=" << ros
                            << ", ieta=" << ieta
                            << ", iphi=" << iphi
                            << ", hitTrue=" << ttHit[ieta]
                            << ", Good=" << Good
                            << ", peak Amp=" << ttAmp[ieta][peakSamp]
                            << ", with noise=" << ttL1samples[0] << endmsg;
          }
 
          // ATLAS Level1 Calo Trigger
        } else {
          double ttL1NoiseSigma = m_tileInfo->TTL1NoiseSigma(ttId[ieta]);
          double ttL1Thresh = m_tileInfo->TTL1Thresh(ttId[ieta]);
          double ttL1Ped = m_tileInfo->TTL1Ped(ttId[ieta]);
          double ttL1Calib = m_tileInfo->TTL1Calib(ttId[ieta]);
          double ttL1Max = m_tileInfo->TTL1Max(ttId[ieta]);
 
          if (m_tileNoise)
            RandGaussQ::shootArray(rngWrapper->getEngine(ctx), m_nSamples, Rndm);
          for (int jsamp = 0; jsamp < m_nSamples; ++jsamp) {
            ttAmp[ieta][jsamp] *= ttL1Calib; // convert pCb to mV
            ttL1samples[jsamp] = ttAmp[ieta][jsamp] + ttL1Ped;
            if (m_tileNoise)
              ttL1samples[jsamp] += ttL1NoiseSigma * Rndm[jsamp];
 
            // check if the voltage is above the saturation point,
            // if so, set the pulse value to the saturation point
            if (ttL1samples[jsamp] > ttL1Max)
              ttL1samples[jsamp] = ttL1Max;
 
          }  // end loop over samples
 
          if (m_tileThresh) {
            if (ttL1samples[m_iTrig] - ttL1Ped < ttL1Thresh)
              Good = false;
          }
          if (msgLvl(MSG::DEBUG) && Good) {
            msg(MSG::DEBUG) << " TTL1:  "
                            << " ros=" << ros
                            << ", ieta=" << ieta
                            << ", iphi=" << iphi
                            << ", hitTrue=" << ttHit[ieta]
                            << ", Good=" << Good
                            << ", amp0=" << ttAmp[ieta][m_iTrig]
                            << ", digitIn=" << ttL1samples[m_iTrig] << endmsg;
          }
        }
      } // end first "Good" section.
 
      /* Create the new TTL1 object and store in TTL1Container. */
      if (Good) {
        std::unique_ptr<TileTTL1> ttl1 = std::make_unique<TileTTL1>(ttId[ieta], ttL1samples);
        ttl1Container->push_back(ttl1.release());
      }  // end second "Good" section.
    } // end loop over towers
  } // end loop over collections
 
  // sort all trigger towers according to identifier
  if (m_cosmicsType) {
    ATH_MSG_DEBUG( "Sorting container of size " << ttl1Container->size() );
    TileLogicalOrdering<TileTTL1> order;
    ttl1Container->sort(order);
  }
 
  if (mbtsTTL1Container) {
    SG::WriteHandle<TileTTL1Container> mbtsContainer(m_mbtsTTL1ContainerKey, ctx);
    ATH_CHECK( mbtsContainer.record(std::move(mbtsTTL1Container)));
 
    ATH_MSG_DEBUG( "MBTS TileTTL1Container registered successfully (" << m_mbtsTTL1ContainerKey.key() << ")" );
  }
 
  // Execution completed.
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << "TileHitToTTL1 execution completed." << endmsg;
    msg(MSG::DEBUG) << " nTTTot=" << nTTTot
                    << " nHitTot=" << nHitTot
                    << " nIgnoreTot=" << nIgnoreTot
                    << "  ttAmpTot=" << ttAmpTot
                    << " ttAmpTotIg=" << ttAmpTotIg
                    << " =>eneTot=" << ttAmpTot + ttAmpTotIg << endmsg;
  }
 
  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();
}

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

overridevirtual

finalize method

Definition at line 680 of file TileHitToTTL1.cxx.

                                   {
 
  ATH_MSG_INFO( "TileHitToTTL1::finalize() end" );
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TileHitToTTL1::initialize ( )

overridevirtual

initialize method

Definition at line 65 of file TileHitToTTL1.cxx.

                                     {
 
  // retrieve CaloLVL1_ID, TileID, TileHWID helpers and TileIfno from det store
 
  ATH_CHECK( detStore()->retrieve(m_TT_ID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileTBID) );
 
  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
 
  //=== Get Tile Info
  ATH_CHECK( detStore()->retrieve(m_tileInfo, m_infoName) );
 
  ATH_CHECK( m_badChannelsKey.initialize(m_maskBadChannels) );
 
  ATH_CHECK( m_emScaleKey.initialize() );
 
  //=== Get rndm number service
  ATH_CHECK( m_rndmSvc.retrieve() );
 
  ATH_CHECK( m_samplingFractionKey.initialize() );
 
  ATH_CHECK( m_cablingSvc.retrieve() );
  m_cabling = m_cablingSvc->cablingService();
 
  // The 'cosmics' setting refers to running with the 
  // Tile/Chicago Cosmic boards instead of the L1Calo
  // This is a pre-2009 configuration
  // The 'standard' setting is the L1Calo configuration
  m_cosmicsType = (m_TileTTL1Type == "Cosmics");
 
  if (m_TileTTL1Type == "Cosmics") {
    ATH_MSG_INFO( "Cosmics TTL1 type selected" );
 
  } else if (m_TileTTL1Type == "Standard") {
    ATH_MSG_INFO( "Standard TTL1 type selected" );
 
  } else {
    ATH_MSG_INFO( "TileHitToTTL1 failed to recognize the TileTTL1Type: " << m_TileTTL1Type );
    return StatusCode::FAILURE;
  }
 
  if (m_mbtsTTL1ContainerKey.key().empty()) {
    ATH_MSG_INFO( "TileTTL1 from MBTS will not be produced" ); 
  } else {
    ATH_MSG_INFO( "Storing MBTS TileTTL1 in separate container " << m_mbtsTTL1ContainerKey.key() );
  }
  ATH_CHECK( m_mbtsTTL1ContainerKey.initialize(SG::AllowEmpty) );
 
  if (m_maskBadChannels) {
    ATH_MSG_INFO( "Bad Channel trigger status will be applied" );
  } else {
    ATH_MSG_INFO(  "Bad Channel trigger status will be ignored" );
  }
 
  /*............................................................................*/
  // Get all global parameters that will be needed for processing
  // For Cosmics, convolute sub-hits with full shape, producing a fine-grained
  // vector for each tower. After noise/pedestal, calculate peak value and 
  // put only that in TileTTL1 object, otherwise TileTTL1 will be too large.
  // For now, use the same shape for L1 and cosmics, but the latter should
  // be wider, will change soon.
  // For Standard L1, also convolute sub-hits with fine-grained shape, but 
  // produce sample-grained vector in TileTTL1.*/
  // Load the pulse shape (so as to not perform this on every execution)
  // The pulse shape for the MBTS, L1Calo (standard) config and the 
  // cosmics config is the same
  // Right now the phase is set to zero (the pulse is centered)
  m_nSamples = m_tileInfo->NdigitSamples(); // number of time slices for each chan
  m_iTrig = m_tileInfo->ItrigSample();   // index of the triggering time slice
  double phase = 0.0;
  std::vector<double> ttl1Shape(m_nSamples, 0.);
  m_tileInfo->ttl1Shape(m_nSamples, m_iTrig, phase, ttl1Shape);
  if (msgLvl(MSG::DEBUG)) {
    for (int jsamp = 0; jsamp < m_nSamples; ++jsamp) {
      msg(MSG::DEBUG) << "jsamp=" << jsamp << " ttl1shape=" << ttl1Shape[jsamp] << endmsg;
    } // end of pulse shape loading
  }
 
  // Data for MBTS
  // The MBTS have a special hardware configuration. The trigger uses the tower
  // output but the high gain from the 3&1 card
  m_MBTSiTrig = m_tileInfo->ItrigSample();
  m_MBTSnSamples = m_tileInfo->NdigitSamples();
 
  // Get TileNoise flag from TileInfo (true => generate noise in TileDigits) 
  m_tileNoise = m_tileInfo->TileNoise();
  // Get TileZeroSuppress flag from TileInfo (true => apply threshold to Digits) 
  m_tileThresh = m_tileInfo->TileZeroSuppress();
 
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << " TTL1Shape[" << m_iTrig << "]=" << ttl1Shape[m_iTrig] << endmsg;
 
    msg(MSG::DEBUG) << " nSamples=" << m_nSamples
                    << ", iTrig=" << m_iTrig
                    << ", tileNoise=" << ((m_tileNoise) ? "true" : "false")
                    << ", tileThresh=" << ((m_tileThresh) ? "true" : "false") << endmsg;
  }
 
  ATH_CHECK( m_hitContainerKey.initialize() );
  ATH_CHECK( m_ttl1ContainerKey.initialize() );
 
  ATH_MSG_INFO( "TileHitToTTL1 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.

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_badChannelsKey

SG::ReadCondHandleKey<TileBadChannels> TileHitToTTL1::m_badChannelsKey

private

Initial value:

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

Name of TileBadChannels in condition store.

Definition at line 152 of file TileHitToTTL1.h.

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

m_cabling

const TileCablingService* TileHitToTTL1::m_cabling {nullptr}

private

Pointer to the TileCablingService instance.

Definition at line 117 of file TileHitToTTL1.h.

{nullptr}; 

m_cablingSvc

ServiceHandle<TileCablingSvc> TileHitToTTL1::m_cablingSvc

private

Initial value:

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

Name of Tile cabling service.

Definition at line 136 of file TileHitToTTL1.h.

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

m_cosmicsType

bool TileHitToTTL1::m_cosmicsType {false}

private

if true => use dediated cosmcis TTL1

Definition at line 110 of file TileHitToTTL1.h.

{false};              

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_emScaleKey

SG::ReadCondHandleKey<TileEMScale> TileHitToTTL1::m_emScaleKey

private

Initial value:

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

Name of TileEMScale in condition store.

Definition at line 146 of file TileHitToTTL1.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_hitContainerKey

SG::ReadHandleKey<TileHitContainer> TileHitToTTL1::m_hitContainerKey

private

Initial value:

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

Definition at line 93 of file TileHitToTTL1.h.

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

m_infoName

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

private

Initial value:

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

Definition at line 87 of file TileHitToTTL1.h.

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

m_iTrig

int TileHitToTTL1::m_iTrig {0}

private

index of the triggering time slice

Definition at line 122 of file TileHitToTTL1.h.

{0};          

m_lastTower

int TileHitToTTL1::m_lastTower {15}

private

total number of towers in TileCal

Definition at line 128 of file TileHitToTTL1.h.

{15};    

m_maskBadChannels

Gaudi::Property<bool> TileHitToTTL1::m_maskBadChannels

private

Initial value:

{this,
        "maskBadChannels", true, "If true then bad channels are masked"}

Definition at line 84 of file TileHitToTTL1.h.

                                         {this,
        "maskBadChannels", true, "If true then bad channels are masked"};

m_MBTSiTrig

int TileHitToTTL1::m_MBTSiTrig {0}

private

index of the triggering time slice for MBTS TTL1

Definition at line 126 of file TileHitToTTL1.h.

{0};      

m_MBTSnSamples

int TileHitToTTL1::m_MBTSnSamples {0}

private

number of time slices for each chan for MBTS TTL1

Definition at line 125 of file TileHitToTTL1.h.

{0}; 

m_mbtsTTL1ContainerKey

SG::WriteHandleKey<TileTTL1Container> TileHitToTTL1::m_mbtsTTL1ContainerKey

private

Initial value:

{this,"TileMBTSTTL1Container",
                                                                 "TileTTL1MBTS",
                                                                 "Output Tile MBTS TTL1 container key"}

Definition at line 100 of file TileHitToTTL1.h.

                                                              {this,"TileMBTSTTL1Container",
                                                                 "TileTTL1MBTS",
                                                                 "Output Tile MBTS TTL1 container key"};

m_nSamples

int TileHitToTTL1::m_nSamples {0}

private

number of time slices for each channel

Definition at line 121 of file TileHitToTTL1.h.

{0};     

m_randomStreamName

Gaudi::Property<std::string> TileHitToTTL1::m_randomStreamName {this, "RandomStreamName", "Tile_HitToTTL1", ""}

private

Random Stream Name.

Definition at line 141 of file TileHitToTTL1.h.

{this, "RandomStreamName", "Tile_HitToTTL1", ""};

m_rndmSvc

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

private

Random number generator engine to use.

Definition at line 139 of file TileHitToTTL1.h.

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

m_samplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> TileHitToTTL1::m_samplingFractionKey

private

Initial value:

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

Name of TileSamplingFraction in condition store.

Definition at line 107 of file TileHitToTTL1.h.

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

m_tileHWID

const TileHWID* TileHitToTTL1::m_tileHWID {nullptr}

private

Pointer to TileHWID helper.

Definition at line 114 of file TileHitToTTL1.h.

{nullptr}; 

m_tileID

const TileID* TileHitToTTL1::m_tileID {nullptr}

private

Pointer to TileID helper.

Definition at line 112 of file TileHitToTTL1.h.

{nullptr};   

m_tileInfo

const TileInfo* TileHitToTTL1::m_tileInfo {nullptr}

private

Pointer to TileInfo.

Definition at line 115 of file TileHitToTTL1.h.

{nullptr}; 

m_tileNoise

bool TileHitToTTL1::m_tileNoise {false}

private

If true => generate noise for the TileTTL1 creation.

Definition at line 130 of file TileHitToTTL1.h.

{false};   

m_tileTBID

const TileTBID* TileHitToTTL1::m_tileTBID {nullptr}

private

Pointer to TileID helper.

Definition at line 113 of file TileHitToTTL1.h.

{nullptr}; 

m_tileThresh

bool TileHitToTTL1::m_tileThresh {false}

private

If true => apply threshold on the conversion to TileTTL1.

Definition at line 131 of file TileHitToTTL1.h.

{false};  

m_TileTTL1Type

Gaudi::Property<std::string> TileHitToTTL1::m_TileTTL1Type

private

Initial value:

{this,
        "TileTTL1Type", "Standard", "Name of Trigger Type"}

Definition at line 90 of file TileHitToTTL1.h.

                                           {this,
        "TileTTL1Type", "Standard", "Name of Trigger Type"};

m_TT_ID

const CaloLVL1_ID* TileHitToTTL1::m_TT_ID {nullptr}

private

Pointer to TT Identifier.

Definition at line 116 of file TileHitToTTL1.h.

{nullptr}; 

m_ttl1ContainerKey

SG::WriteHandleKey<TileTTL1Container> TileHitToTTL1::m_ttl1ContainerKey

private

Initial value:

{this,"TileTTL1Container",
                                                             "TileTTL1Cnt",
                                                             "Output Tile TTL1 container key"}

Definition at line 96 of file TileHitToTTL1.h.

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

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:

• TileHitToTTL1.h
• TileHitToTTL1.cxx