TilePulseForTileMuonReceiver Class Reference

#include <TilePulseForTileMuonReceiver.h>

Inheritance diagram for TilePulseForTileMuonReceiver:

Public Member Functions
	TilePulseForTileMuonReceiver (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TilePulseForTileMuonReceiver ()
virtual StatusCode	initialize () override
	initialize method
virtual StatusCode	execute () override
	execute method
virtual StatusCode	finalize () override
	finalize method
virtual bool	isClonable () const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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
SG::ReadHandleKey< TileDigitsContainer >	m_inputDigitContainerKey {this, "InputTileDigitContainer","",""}
std::string	m_inputDigitContainerName {""}
SG::ReadHandleKey< TileHitContainer >	m_hitContainerKey
SG::WriteHandleKey< TileDigitsContainer >	m_muRcvDigitsContainerKey
SG::WriteHandleKey< TileRawChannelContainer >	m_muRcvRawChannelContainerKey
SG::ReadCondHandleKey< TileSamplingFraction >	m_samplingFractionKey
	Name of TileSamplingFraction in condition store.
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_PulseForTileMuonReceiver", ""}
	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< TileBadChannels >	m_badChannelsKey
	Name of TileBadChannels in condition store.
ToolHandle< TileRawChannelBuilderMF >	m_MuRcvBuildTool
Gaudi::Property< std::string >	m_infoName {this, "TileInfoName", "TileInfo", "TileInfo object name"}
Gaudi::Property< bool >	m_integerDigits {this, "IntegerDigits", false, "Round digits (default=false)"}
Gaudi::Property< bool >	m_maskBadChannels {this, "MaskBadChannels", false, "Remove channels tagged bad (default=false)"}
Gaudi::Property< bool >	m_useCoolPulseShapes {this, "UseCoolPulseShapes", false, "Pulse shapes from database (default=false)"}
Gaudi::Property< bool >	m_tileNoise {this, "UseCoolNoise", false, "Noise from database (default=false)"}
Gaudi::Property< bool >	m_tilePedestal {this, "UseCoolPedestal", false, "Pedestal from database (default=false)"}
Gaudi::Property< bool >	m_rndmEvtOverlay {this, "RndmEvtOverlay", false, "Pileup and/or noise added by overlaying random events (default=false)"}
Gaudi::Property< bool >	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
const TileID *	m_tileID
const TileHWID *	m_tileHWID
const TileInfo *	m_tileInfo
const TileCablingService *	m_cablingService
	TileCabling instance.
int	m_nSamples
	Number of time slices for each channel.
int	m_iTrig
	Index of the triggering time slice.
int	m_adcMax
	ADC saturation value.
double	m_tileThresh
	Actual threshold value.
int	m_nShape
	Number of bins in pulse shape.
int	m_nBinsPerX
	Number of bins per bunch crossing in pulse shape.
int	m_binTime0
	Index of time=0 bin for pulse shape.
double	m_timeStep
	Time step in pulse shape: 25.0 / nBinsPerX.
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc"}
std::vector< double >	m_shapeMuonReceiver
	Muon receiver pulse shape.
int	m_runPeriod
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 80 of file TilePulseForTileMuonReceiver.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TilePulseForTileMuonReceiver()

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

Definition at line 70 of file TilePulseForTileMuonReceiver.cxx.

  : AthAlgorithm(name, pSvcLocator)
  , m_tileID(nullptr)
  , m_tileHWID(nullptr)
  , m_tileInfo(nullptr)
  , m_cablingService(nullptr)
  , m_nSamples(0)
  , m_iTrig(0)
  , m_adcMax(0)
  , m_tileThresh(0.0)
  , m_nShape(0)
  , m_nBinsPerX(0)
  , m_binTime0(0)
  , m_timeStep(0.0)
  , m_runPeriod(0)
{
}

~TilePulseForTileMuonReceiver()

TilePulseForTileMuonReceiver::~TilePulseForTileMuonReceiver ( )

virtual

Definition at line 90 of file TilePulseForTileMuonReceiver.cxx.

                                                            {
}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< 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< 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< 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< 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 TilePulseForTileMuonReceiver::execute ( )

overridevirtual

execute method

Definition at line 191 of file TilePulseForTileMuonReceiver.cxx.

                                                 {
 
  if (m_runPeriod==0)  {
    ATH_MSG_VERBOSE( "ATT: RUN1 settings TilePulseForTileMuonReceiver will end now" );
    return StatusCode::SUCCESS;
  } else {
    ATH_MSG_DEBUG( "Executing TilePulseForTileMuonReceiver" );
  }
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Conversion from TMDB channel number to channel number in a drawer: EB (0-3) LB (0-8)
  // Including the cells used in the "The potential of using the ATLAS Tile calorimeter in Phase-II for the
  // Level-0 muon trigger" (ATL-COM-TILECAL-2015-007.pdf): ALL D-layer + BC-8.
  //
#define nEBchan 6
#define nLBchan 9
  // EB: D5(L,R),D6(L,R),D4(L,R)
  int EBchan[nEBchan]={17,16,37,38,3,2};
  // LB: D0,D1(L,R),D2(L,R),D3(L,R),BC8(L,R)
  int LBchan[nLBchan]={0,13,14,25,24,41,44,39,40};
  // Set to maximum possible index 
#if (nEBchan > nLBchan)
  double pDigitSamplesArray[nEBchan][7];
  double pDigitSamplesRndmArray[nEBchan][7];
#else
  double pDigitSamplesArray[nLBchan][7];
  double pDigitSamplesRndmArray[nLBchan][7];
#endif
 
  // PULSE
 
  // Random generators output arrays
  //
  double Rndm[16];
  double Rndm_dG[1];
 
  // Noise and pedestal from db
  //
  double pedSim = 0.;
  double sigma_Hfn1 = 0.;
  double sigma_Hfn2 = 0.;
  double sigma_Norm = 0.;
  double sigmaSim(0.0);
 
  // Measured parameters: noise, pedestal and calibration
  //
  double muRcv_NoiseSigma;
  double muRcv_Ped;
  double muRcv_Calib;
  double muRcv_Max;
 
  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;
  }
 
  const TilePulse* pulse = nullptr;
  if (m_useCoolPulseShapes) {
    SG::ReadCondHandle<TilePulse> pulseShape(m_pulseShapeKey, ctx);
    ATH_CHECK( pulseShape.isValid() );
    pulse = pulseShape.retrieve();
  }
 
  const TileSampleNoise* sampleNoise = nullptr;
  if (m_tilePedestal || m_tileNoise) {
    SG::ReadCondHandle<TileSampleNoise> sampleNoiseHandle(m_sampleNoiseKey, ctx);
    ATH_CHECK( sampleNoiseHandle.isValid() );
    sampleNoise = sampleNoiseHandle.retrieve();
  }
 
  // Get hit container from TES
  //
  SG::ReadHandle<TileHitContainer> hitContainer(m_hitContainerKey, ctx);
  ATH_CHECK( hitContainer.isValid() );
 
  // Set up buffers for handling information in a single collection.
  //
  IdentifierHash idhash;
  IdContext drawer_context = m_tileHWID->drawer_context();
 
  // Get a container for the digits
  //
  auto muRcvDigitsContainer = std::make_unique<TileMutableDigitsContainer>(true,
                                                                           TileFragHash::Digitizer,
                                                                           TileRawChannelUnit::ADCcounts);
  ATH_CHECK( muRcvDigitsContainer->status() );
    
  // Get a container for the raw channels
  //
  auto muRcvRawChannelContainer = std::make_unique<TileMutableRawChannelContainer>(true,
                                                                                   TileFragHash::MF,
                                                                                   TileRawChannelUnit::MegaElectronVolts,
                                                                                   SG::VIEW_ELEMENTS);
  ATH_CHECK( muRcvRawChannelContainer->status() );
 
  // Prepare container for MC Overlay procedure
  //
  TileDigitsContainer::const_iterator collItrRndm;
  TileDigitsContainer::const_iterator lastCollRndm;
  std::unique_ptr<TileMutableDigitsContainer> backgroundDigitContainer{};
 
  if (m_rndmEvtOverlay) {
 
    ATH_MSG_DEBUG("Prepare background container for MC Overlay procedure");
 
    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();
  }
 
  // Vector of digits to set into the container
  //
  std::vector<float> digitsBuffer(m_nSamples);
 
  // Vector(s) for MC Overlay procedure
  //
  std::vector<float> digitsBuffer_rndm(m_nSamples);
  std::vector<bool> good_bkg( 9 , false );
 
  // Prepare RNG service
  //
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName, ctx );
  CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);

  // (a.0) iterate over collections in the HIT container: access 'ros' and 'drawer'
  //
  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
  ATH_CHECK( samplingFraction.isValid() );
 
  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);
    bool eb_ros   = ((ros == TileHWID::EXTBAR_POS) || (ros == TileHWID::EXTBAR_NEG));
    int upperLim  = (eb_ros) ? nEBchan : nLBchan;
 
    ATH_MSG_VERBOSE("(A.00) Looping over all collections for TMDB in the HIT container");
    memset(pDigitSamplesArray, 0, sizeof(pDigitSamplesArray));
 
    ATH_MSG_VERBOSE("(A.01) Going through collection ROS/DRAWER : "<< ros <<"/"<< drawer);
    ATH_MSG_DEBUG(" Going through collection ROS/DRAWER : "<< ros <<"/"<< drawer);
 
    if (m_cablingService->connected(ros, drawer)) {
      ATH_MSG_VERBOSE("(A.02)   ROS: "<< ros << " drawer: " << drawer << " is connected");
    } else {
      ATH_MSG_VERBOSE("(A.02)   ROS: "<< ros << " drawer: " << drawer << " is NOT connected");
      continue;
    }
 
    // Get drawer idhash for later access to the database to get ped and noise
    //
    m_tileHWID->get_hash(drawer_id, idhash, &drawer_context);
 
    // **************************************************************
    //
    // Prepare buffer for MC Overlay procedure: pileup digits
    //
 
    memset(pDigitSamplesRndmArray, 0, sizeof(pDigitSamplesRndmArray));
 
    if (m_rndmEvtOverlay && collItrRndm != lastCollRndm) {
 
      const TileDigitsCollection *bkgDigitCollection(*collItrRndm);
 
      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;
      }
 
      ATH_MSG_DEBUG("Prepare buffer (digitsBuffer_rndm) for MC Overlay procdure: pileup digits");
 
      for (const auto* bkgDigit : *bkgDigitCollection) {
        bool good_channel = true;
        /* Get digit HWIdentifier (= adc_id) */
        HWIdentifier adc_id_rndm = (*bkgDigit).adc_HWID();
        int channel = m_tileHWID->channel(adc_id_rndm);
        ATH_MSG_VERBOSE ( "check channels from adc id in rndm container (TMDB channel): "<< channel );
        /* Get digits */
        digitsBuffer_rndm = (*bkgDigit).samples();
        /* Get number of sample and compare with nSamples */
        int nsamp_rndm = digitsBuffer_rndm.size();
        if (nsamp_rndm != m_nSamples) {
          digitsBuffer_rndm.resize(m_nSamples);
          if (nsamp_rndm>0) {
            for (int js=nsamp_rndm; js<m_nSamples; ++js) {
              digitsBuffer_rndm[js] = digitsBuffer_rndm[js-1];
            }
          }
        }
        /* Fill the background digits array for the current channel and set a flag if any digit is NULL */
        for (int j=0; j< m_nSamples;j++) {
          pDigitSamplesRndmArray[channel][j] = digitsBuffer_rndm[j];
          // If any digit is 0 something should be wrong so flag it in order to use during overlay the standard
          // path to fill the expected background level for that channel
          if (pDigitSamplesRndmArray[channel][j]==0) good_channel = false;
        }
        good_bkg[channel] = good_channel;
 
        if (msgLvl(MSG::VERBOSE)){
            msg(MSG::VERBOSE) << " Digits from pileup background " << channel << " " << ros << " " << drawer << " " << m_tileHWID->to_string(adc_id_rndm)<<" | ";
            for (int j=0; j< (int) digitsBuffer_rndm.size(); j++) msg(MSG::VERBOSE) << digitsBuffer_rndm[j] <<" | ";
            msg(MSG::VERBOSE) << "---> | ";
            for (int j=0; j< (int) digitsBuffer_rndm.size(); j++) msg(MSG::VERBOSE) << pDigitSamplesRndmArray[channel][j] << " | ";
            msg(MSG::VERBOSE) << endmsg;
        }
      }
      ++collItrRndm; // skip to next digi collection
    }

    // (a.1) Iterate over all hits in a collection : access 'channel'
    //
 
    if ( hitCollection->empty() ) ATH_MSG_DEBUG("-- No hits in this drawer! Filling channels with either noise and pedestal or MC pileup overlay. --");
 
    for (const TileHit* tile_hit : *hitCollection) {
 
      // Get the pmt ID
      //
      Identifier pmt_id = tile_hit->pmt_ID();
 
      // keep only D-cells and in addition cell BC8
      // 
      int tower = m_tileID->tower(pmt_id);
      int sample = m_tileID->sample(pmt_id);
      if ( ! ((sample == TileID::SAMP_D) || (sample == TileID::SAMP_BC && tower == 7)) ) continue;
 
      ATH_MSG_VERBOSE("(B.00) ++ Iterate over all the D layer channels with hits");
 
      // In COOL database data will be organized acoording to TMDB channel (TMDBchan): 0..n with n=5 in EB and n=8 in LB 
      int TMDBchan;
      // In here we need to access the real TILE HW channel (TILEchan) that it has a correspondance with TMDB chan given by EBchan and LBNchan
      int TILEchan;
 
      if (eb_ros) {
         // cells D5, D6 and then D4 at the end
         if (m_tileID->side(pmt_id) > 0)
            TMDBchan = 1 - m_tileID->pmt(pmt_id) + ((tower>9) ? (tower - 10) : 4);
         else
            TMDBchan =     m_tileID->pmt(pmt_id) + ((tower>9) ? (tower - 10) : 4);
 
         TILEchan=EBchan[TMDBchan];
      } else {
        // Barrel (extension for HL-LHC)
        if (tower == 0) {
           TMDBchan = 0; // cell D0, channel 0 always
        } else {
          // cells D1. D2, D3 and BC8
          if (m_tileID->side(pmt_id) > 0)
             TMDBchan = 1 - m_tileID->pmt(pmt_id) + ((tower<7) ? (tower-1) : 7);
          else
             TMDBchan =     m_tileID->pmt(pmt_id) + ((tower<7) ? (tower-1) : 7);
        }
 
        TILEchan=LBchan[TMDBchan];
      }
 
      double* pDigitSamples = pDigitSamplesArray[TMDBchan];
 
      if (msgLvl(MSG::VERBOSE)){
         HWIdentifier adc_id = m_tileHWID->adc_id(drawer_id, TMDBchan, TileID::LOWGAIN);
 
         ATH_MSG_VERBOSE( "(B.01) Correct pmt being transported in XXchan[]: "<<TMDBchan<<" "<<TILEchan<< "=?"
                         << m_tileHWID->channel(m_cablingService->s2h_channel_id(pmt_id))
                         << " For reference get TMDB adc_id: " << m_tileHWID->to_string(adc_id)  );
         ATH_MSG_VERBOSE( "(B.02) New hit in ROS/DRAWER/PMT "<<ros<<"/"<<drawer<<"/"<<TMDBchan<<" ("<<TILEchan<<")"
                         << " pmt_id "<< m_tileID->to_string(pmt_id,-1)
                         << " adc_id "<< m_tileHWID->to_string(adc_id)  );
      }
      
      // Scintillator Energy -> Cell Energy (uses sampling fraction)
      //
      int channel = m_tileHWID->channel(m_cablingService->s2h_channel_id(pmt_id));
      double hit_calib = samplingFraction->getSamplingFraction(drawerIdx, channel);
      hit_calib = std::round(hit_calib * 1000) / 1000;
 
      ATH_MSG_VERBOSE("------ Sampling fraction: " << hit_calib);

      // (a.2) Loop over the hits of this channel
      //       Calibrations are applied per subhit and energy added per subhit of a channel
      //
 
      int n_hits = tile_hit->size();
 
      ATH_MSG_VERBOSE("------ Number of hits in channel: " << n_hits);
 
      for (int ihit = 0; ihit < n_hits; ++ihit) {
 
        ATH_MSG_VERBOSE("(C.00) ++ Iterating over the hits of channel " << TILEchan <<": hit " << ihit <<"/"<< n_hits);
 
        double e_hit = tile_hit->energy(ihit); // [MeV] energy deposited in scintillator
        double e_pmt = e_hit * hit_calib;      // [MeV] true cell energy
 
        ATH_MSG_VERBOSE("(C.01) Energy in scintillator [MeV]: " << e_hit << " true cell energy [MeV]: " << e_pmt);
 
        double t_hit = tile_hit->time(ihit);
 
        ATH_MSG_VERBOSE("(C.02.01) Phase " << t_hit);
 
        // Load pulse
        //
        int   k      = 0;
        float phase  = 0.0;
        float y      = 0.0;
        float dy     = 0.0;
        double shape = 0.0;
 
        int ishift = (int) (t_hit / m_timeStep + 0.5);
 
        ATH_MSG_VERBOSE( "(C.02.02)   ishift :" << t_hit << "/" << m_timeStep << "+0.5 = " << ishift);
 
        if (m_useCoolPulseShapes) {
          for (int js = 0; js < m_nSamples; ++js) {
            k = m_binTime0 + (js - m_iTrig) * m_nBinsPerX - ishift;
            if (k < 0) k = 0;
            else if (k > m_nShape) k = m_nShape;
 
            ATH_MSG_VERBOSE( "(C.02.03)   k : " << m_binTime0 << "+(" << js << "-" << m_iTrig << ")*" << m_nBinsPerX <<  "-" << ishift << " = " << k);
 
            phase = (k - m_binTime0) * m_timeStep;
 
            ATH_MSG_VERBOSE( "(C.02.04)   phase : " << k << "-" << m_binTime0 << "*" << m_timeStep << " = " << phase);
 
            pulse->getPulseShapeYDY(drawerIdx, TMDBchan, TileID::LOWGAIN, phase, y, dy);
            shape = (double) y;
            pDigitSamples[js] += e_pmt * shape; // MeV
 
            ATH_MSG_VERBOSE( "(C.03.0) Sample no.= " << js
                            << " idx= " << k
                            << " Shape wt. = " << shape
                            << " Amp = " << pDigitSamples[js] << " [MeV]");
          } //END loop over samples
        } else {
          for (int js = 0; js < m_nSamples; ++js) {
            k = m_binTime0 + (js - m_iTrig) * m_nBinsPerX - ishift;
            if (k < 0) k = 0;
            else if (k > m_nShape) k = m_nShape;
 
            ATH_MSG_VERBOSE( "(C.02.03)   k : " << m_binTime0 << "+(" << js << "-" << m_iTrig << ")*" << m_nBinsPerX <<  "-" << ishift << " = " << k);
 
            pDigitSamples[js] += e_pmt * m_shapeMuonReceiver[k]; // MeV
 
            ATH_MSG_VERBOSE( "(C.03.0) Sample no.= " << js
                            << " idx= " << k
                            << " Shape wt. = " << m_shapeMuonReceiver[k]
                            << " Amp = " << pDigitSamples[js]
                            << "[MeV]  Energy: " << e_pmt << " LOGAIN from TileInfo");
          } //END loop over samples
        } // END if (m_useCoolPulseShapes)
      } // END loop over sub-HITS
 
      ATH_MSG_VERBOSE("++ ENDED Loop over hits for a channel");
      ATH_MSG_DEBUG("(C.04) Went over " << n_hits << " hits for channel"
                    << m_tileHWID->to_string(drawer_id,-2) << "/" << TMDBchan << " (" << TILEchan << ")"
                    << " digits [MeV] "<< pDigitSamples[0]
                    << "/" << pDigitSamples[1]
                    << "/" << pDigitSamples[2]
                    << "/" << pDigitSamples[3]
                    << "/" << pDigitSamples[4]
                    << "/" << pDigitSamples[5]
                    << "/" << pDigitSamples[6]);
      ATH_MSG_VERBOSE("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
    } // END loop over a HIT collection
 
    ATH_MSG_VERBOSE("++ END loop over a HIT collection");

    // (a.3) The pulse has a shape and a amplitude in MeV now it is converted into ADC
    //       counts and either add NOISE and PEDESTAL or the OVERLAY digits
    //
    //       PEDESTAL [ADC counts] and NOISE [ADC counts] as stored in Tile 
    //       Conditions (FIXED values but also flag for collection from COOL)
    //
    //       Keep containers for each module (each partition) the same size 
    //       between events i.e. ALL channels are filled even with ZERO energy
    //
 
    ATH_MSG_VERBOSE("++ START filling of channels with background either noise+pedestal or overlay");
 
    for (int TMDBchan = 0; TMDBchan < upperLim; ++TMDBchan) {
 
      double* pDigitSamples=pDigitSamplesArray[TMDBchan];
      int TILEchan = (eb_ros) ? EBchan[TMDBchan] : LBchan[TMDBchan];
 
      HWIdentifier adc_id = m_tileHWID->adc_id(drawer_id, TMDBchan, TileID::LOWGAIN); 
 
      ATH_MSG_DEBUG( "(D.)        Going now to channel " << " TMDBchan: "   << TMDBchan << " TILEchan: " << TILEchan);
      ATH_MSG_DEBUG( "(D.00)      Add noise and pedestal in "
                       << " TMDBchan: "   << TMDBchan << " TILEchan: " << TILEchan
                       << " ROS: "        << ros
                       << " drawer: "     << drawer
                       << " drawer idx: " << drawerIdx
                       << " drawer_id: "  << m_tileHWID->to_string(drawer_id,-2)
               << " channel: "    << m_tileHWID->to_string(adc_id,-1));
      // adc/pCb / MeV/pCb = adc/MeV
      //
      muRcv_Max   = m_tileInfo->MuRcvMax(adc_id);             // [adc]
      muRcv_Calib = m_tileInfo->MuRcvCalib(adc_id);           // pCb->[adc]
      double mev2ADC_factor = muRcv_Calib / emScale->calibrateChannel(drawerIdx,TILEchan,TileID::LOWGAIN, 1.
                                                                      , TileRawChannelUnit::PicoCoulombs
                                                                      , TileRawChannelUnit::MegaElectronVolts);
      ATH_MSG_VERBOSE( "(D.01)   Channel: "<<ros<<'/'<<drawer<<'/'<< TMDBchan
                << " adc/pCb: "<< muRcv_Calib
                << " Mev/pCb: "<< emScale->calibrateChannel( drawerIdx,
                                                             TILEchan,
                                                             TileID::LOWGAIN,
                                                             1.,
                                                             TileRawChannelUnit::PicoCoulombs,
                                                             TileRawChannelUnit::MegaElectronVolts)
                << " final calibration factor adc/MeV: "<< mev2ADC_factor);
 
      ATH_MSG_VERBOSE( "(D.02)      Pulse digits [MeV]:"
                       << " " << pDigitSamples[0]
                       << " " << pDigitSamples[1]
                       << " " << pDigitSamples[2]
                       << " " << pDigitSamples[3]
                       << " " << pDigitSamples[4]
                       << " " << pDigitSamples[5]
                       << " " << pDigitSamples[6]
                       << " [All ZERO if there is no hit in channel.] ");
 
      if ( good_bkg[TMDBchan] ) {
        // Collecting digits for MC Overlay procedure from overlay container
        // IF good digits ere collected (no ZEROS <> good_bkg[TMDBchan]==true) then add the background to the simulated digits
        // ELSE bad digits (any ZEROS <> good_bkg[TMDBchan]==false) then follow the standard path adding muRcv_Ped and muRvc_NoiseSigma
 
        ATH_MSG_DEBUG("++ Adding to signal digits -- The MC PILE-UP OVERLAY digits " << m_rndmEvtOverlay << " " << m_integerDigits);
 
        for (int js = 0; js < m_nSamples; ++js) {
          // Signal
          //
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<") sample "<< js+1 <<" E_{Signal} [adc]: "<< pDigitSamples[js] * mev2ADC_factor <<" -- Overlay");
          digitsBuffer[js] = pDigitSamples[js] * mev2ADC_factor;
          // Pileup
          //
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<") sample "<< js+1 <<" E_{PileUp} [adc]: "<< pDigitSamplesRndmArray[TMDBchan][js] <<" -- Overlay");
          digitsBuffer[js] += pDigitSamplesRndmArray[TMDBchan][js];
          // Simulated pulse above allowed maximum
          //
          if (digitsBuffer[js] > muRcv_Max) digitsBuffer[js] = muRcv_Max;
          // Rounding the ADC counts
      //
          if (m_integerDigits) digitsBuffer[js] = round(digitsBuffer[js]);
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<") sample "<< js+1 <<" calibration [adc/MeV] "<< mev2ADC_factor <<"-> E_{Signal+PileUp} [adc]: "<< digitsBuffer[js] <<" -- Overlay");
        }
      } else {
        if (m_rndmEvtOverlay) ATH_MSG_INFO("At least one digit is zero in background file using the stadart path to fill pedestal and noise in digits");
        // Different for each channel_id might be the case in the future (now a const. in TileInfoLoader.cxx)
        //
        muRcv_NoiseSigma = m_tileInfo->MuRcvNoiseSigma(adc_id); // [adc]
        muRcv_Ped   = m_tileInfo->MuRcvPed(adc_id);             // [adc]
 
        ATH_MSG_VERBOSE( "(D.03)      Tile Muon Receiver parameters:"
                 << " noi " << muRcv_NoiseSigma
                 << " ped " << muRcv_Ped
                 << " cal " << muRcv_Calib
                 << " max " << muRcv_Max);
 
        // Collecting digits for standard procedure NO OVERLAY: pedestal+noise
        // ADD digitsBuffer[m_nSamples] WITH Ped and Noise from COOLDB/ATHENA
        //
        ATH_MSG_DEBUG("++ Adding to signal digits -- The PEDESTAL + NOISE digits "<< m_tilePedestal <<" "<< m_tileNoise << " " << m_integerDigits);
        // Collecting pedestal from the database
        //
        if (m_tilePedestal) {
          pedSim = sampleNoise->getPed(idhash, TMDBchan, TileID::LOWGAIN);
          // As in TileDigitsMaker bug fix for wrong ped value in DB
          //
          if (pedSim == 0.0) pedSim = 30.;
        } else {
          pedSim = muRcv_Ped;
        }
        // Collecting noise from the database
        //
        if (m_tileNoise) {
          // Generate an array to randomize the noise for each digit
          //
          RandGaussQ::shootArray(rndmEngine, m_nSamples, Rndm, 0.0, 1.0);
          RandFlat::shootArray(rndmEngine, 1, Rndm_dG, 0.0, 1.0);
          sigma_Hfn1 = sampleNoise->getHfn1(idhash, TMDBchan, TileID::LOWGAIN);
          sigma_Hfn2 = sampleNoise->getHfn2(idhash, TMDBchan, TileID::LOWGAIN);
          if (sigma_Hfn1 > 0 || sigma_Hfn2) {
            sigma_Norm = sigma_Hfn1 / (sigma_Hfn1 + sigma_Hfn2 * sampleNoise->getHfnNorm(idhash, TMDBchan, TileID::LOWGAIN));
          } else {
            sigma_Hfn1 = sampleNoise->getHfn(idhash, TMDBchan, TileID::LOWGAIN);
            sigma_Norm = 1.;
          }
          if (Rndm_dG[0] < sigma_Norm) sigmaSim = sigma_Hfn1;
          else sigmaSim = sigma_Hfn2;
        } else {
          sigmaSim = muRcv_NoiseSigma;
        }
        // Loop over samples and either use noise and ped from db or user location (TileInfoLoader.cxx)
        //
        for (int js = 0; js < m_nSamples; ++js) {
          // Signal
          //
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<")   sample "<< js+1 <<" E [MeV]: "<< pDigitSamples[js]);
          digitsBuffer[js] = pDigitSamples[js] * mev2ADC_factor;
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<")   sample "<< js+1 <<" calibration [adc/MeV] "<< mev2ADC_factor <<"-> E [adc]: "<< digitsBuffer[js]);
          // Pedestal (amp)
          //
          digitsBuffer[js] += pedSim;
          ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<")   sample "<< js+1 <<" adding pedestal "<< pedSim <<"-> E [adc]: "<< digitsBuffer[js]);
          // Noise (rms)
          //
          if (m_tileNoise) {
            digitsBuffer[js] += sigmaSim * Rndm[js];
            ATH_MSG_VERBOSE( "(D.02.0"<< js+1 <<")   sample "<< js+1 <<" adding noise "<< sigmaSim * Rndm[js] <<"-> E [adc]: "<< digitsBuffer[js]);
          }
          // Simulated pulse above allowed maximum
          //
          if (digitsBuffer[js] > muRcv_Max) digitsBuffer[js] = muRcv_Max;
          // Rounding the ADC counts
          //
          if (m_integerDigits) digitsBuffer[js] = round(digitsBuffer[js]);
        }
      }
 
      // If channel is good, create TileDigits object and store in container.
      //
      bool chanIsBad = false;
 
      if (m_maskBadChannels) {
        TileBchStatus status = badChannels->getAdcStatus( m_tileHWID->adc_id(drawer_id, TILEchan, TileID::LOWGAIN) );
        chanIsBad = status.isBad();
      }
 
      if (chanIsBad) {
        for (int js = 0; js < m_nSamples; ++js) {
           digitsBuffer[js] = 255;// in TMDB we have 8-bit ADCs
        }
        ATH_MSG_VERBOSE( "(D.03)   Masking Channel: "<< ros << '/' << drawer << '/' << TILEchan <<" ("<< TMDBchan <<") LowGain" );
      } else {
        ATH_MSG_VERBOSE( "(D.03)   Good Channel   : "<< ros << '/' << drawer << '/' << TILEchan <<" ("<< TMDBchan <<") LowGain" );
      }
 
      ATH_MSG_VERBOSE( "++ Changed to TMDB adc_id: " << m_tileHWID->to_string(adc_id) << " and save a TileDigits object into a container." );
      std::unique_ptr<TileDigits> muonReceiverDigits = std::make_unique<TileDigits>(adc_id, digitsBuffer);
      ATH_MSG_VERBOSE( "++ Create a TileRawChannelObject object and set it into a container " );
      TileRawChannel* muRcvRawChannel = m_MuRcvBuildTool->rawChannel(muonReceiverDigits.get(), ctx);
      ATH_CHECK( muRcvDigitsContainer->push_back(std::move(muonReceiverDigits)) );
      ATH_CHECK( muRcvRawChannelContainer->push_back(muRcvRawChannel) );
      if (msgLvl(MSG::DEBUG)){
        ATH_MSG_DEBUG( "++ Channel " << m_tileHWID->to_string(adc_id,-1)
                     << " Digitized pulse [ADC] "<< digitsBuffer[0]
                     << "/" << digitsBuffer[1]
                     << "/" << digitsBuffer[2]
                     << "/" << digitsBuffer[3]
                     << "/" << digitsBuffer[4]
                     << "/" << digitsBuffer[5]
                     << "/" << digitsBuffer[6]  );
        ATH_MSG_DEBUG( "++ Raw channel reconstruction Ch: "<< m_tileHWID->to_string(adc_id,-1)
                     <<" E [ADC]: "<< muRcvRawChannel->amplitude()
                     <<" Time [ns]: "<< muRcvRawChannel->time()
                     <<" Qf: "<< muRcvRawChannel->quality()  );
      }
    }
  } // END loop over all HIT collections in container
  if (msgLvl(MSG::VERBOSE)) muRcvDigitsContainer->print();

  // (a.4) Register the digits container in the TES
  //
 
  ATH_MSG_VERBOSE ( "(A.05)   Send to event store all collected objects " );
 
  SG::WriteHandle<TileDigitsContainer> muRcvDigitsCnt(m_muRcvDigitsContainerKey, ctx);
  ATH_CHECK( muRcvDigitsCnt.record(std::move(muRcvDigitsContainer)) );
 
  SG::WriteHandle<TileRawChannelContainer> muRcvRawChannelCnt(m_muRcvRawChannelContainerKey, ctx);
  ATH_CHECK( muRcvRawChannelCnt.record(std::move(muRcvRawChannelContainer)) );
 
  ATH_MSG_VERBOSE( "TilePulseForTileMuonReceiver execution completed" );
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.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 Algorithm::extraOutputDeps();
}

finalize()

StatusCode TilePulseForTileMuonReceiver::finalize ( )

overridevirtual

finalize method

Definition at line 823 of file TilePulseForTileMuonReceiver.cxx.

                                                  {
  ATH_MSG_VERBOSE("Finalizing TilePulseForTileMuonReceiver");
 
  ATH_MSG_INFO("TilePulseForTileMuonReceiver finalized successfully");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TilePulseForTileMuonReceiver::initialize ( )

overridevirtual

initialize method

Definition at line 95 of file TilePulseForTileMuonReceiver.cxx.

                                                    {
 
  //  Check cabling RUN>=RUN2 OK
  //
  ATH_CHECK( m_cablingSvc.retrieve() );
  m_cablingService = m_cablingSvc->cablingService();
  m_runPeriod = m_cablingService->runPeriod();
 
  // Handles must always be initialised
  ATH_CHECK( m_hitContainerKey.initialize(m_runPeriod != 0) );
  ATH_CHECK( m_muRcvDigitsContainerKey.initialize(m_runPeriod != 0) );
  ATH_CHECK( m_muRcvRawChannelContainerKey.initialize(m_runPeriod != 0) );
  ATH_CHECK( m_inputDigitContainerKey.initialize(!m_onlyUseContainerName && m_rndmEvtOverlay && m_runPeriod != 0) );
  ATH_CHECK( m_samplingFractionKey.initialize(m_runPeriod != 0) );
  ATH_CHECK( m_emScaleKey.initialize(m_runPeriod != 0) );
  ATH_CHECK( m_sampleNoiseKey.initialize((m_runPeriod != 0) && (m_tilePedestal || m_tileNoise)) );
 
  if ( m_runPeriod == 0) {
    ATH_MSG_INFO("TilePulseForTileMuonReceiver should not be used for RUN1 simulations");
    return StatusCode::SUCCESS;
  } else {
    ATH_MSG_INFO("Initializing TilePulseForTileMuonReceiver");
  }
 
  //=== retrieve TileID helper and TileInfo from det store
  ATH_CHECK(detStore()->retrieve(m_tileID));
  ATH_CHECK(detStore()->retrieve(m_tileHWID));
  ATH_CHECK(detStore()->retrieve(m_tileInfo, m_infoName));
 
  ATH_CHECK(m_MuRcvBuildTool.retrieve());
 
  m_nSamples = m_tileInfo->NdigitSamples();    // number of time slices for each chan
  m_iTrig = m_tileInfo->ItrigSample();      // index of the triggering time slice
  m_adcMax = m_tileInfo->ADCmax();          // adc saturation value
  m_tileThresh = m_tileInfo->ThresholdDigits(TileID::LOWGAIN);
 
  ATH_MSG_VERBOSE("Cabling Services: "                << m_cablingService
                   << " Number of Samples: "          << m_nSamples
                   << " Triggering tile slice: "      << m_iTrig
                   << " ADC saturation value: "       << m_adcMax
                   << " TileCal Threshold LOW GAIN: " << m_tileThresh);
 
  ATH_CHECK(m_rndmSvc.retrieve());
 
  m_nShape    = m_tileInfo->MuRcvNBins();
  m_nBinsPerX = m_tileInfo->MuRcvBinsPerX();
  m_binTime0  = m_tileInfo->MuRcvTime0Bin();
  m_timeStep  = 25.0 / m_nBinsPerX;
 
  ATH_MSG_VERBOSE( "Pulse info : "
        << "shape "                  << m_nShape
                <<" nbins "                  << m_nBinsPerX
                <<" time "                   << m_binTime0
                <<" time step "              << m_timeStep
                <<" Triggering tile sample " << m_iTrig);
 
  // decrease by 1, now it is the position of lastest element in a vector
  //
  --m_nShape;
 
  ATH_CHECK( m_pulseShapeKey.initialize((m_runPeriod != 0) && m_useCoolPulseShapes) );
  if (m_useCoolPulseShapes) {
    ATH_MSG_INFO( "Using pulse from database.");
  } else {
    ATH_MSG_INFO( "Using pulse from TileInfo.");
 
    m_shapeMuonReceiver = m_tileInfo->MuRcvFullShape();
    m_shapeMuonReceiver.push_back(0.0);
  }
 
  ATH_CHECK( m_badChannelsKey.initialize((m_runPeriod != 0) && m_maskBadChannels) );
 
  ATH_MSG_INFO( "Integer digits: \t" << ((m_integerDigits)?"true":"false"));
  ATH_MSG_INFO( "Tile Pedestal: \t" << ((m_tilePedestal)?"true":"false"));
  ATH_MSG_INFO( "Tile Noise: \t" << ((m_tileNoise)?"true":"false"));
  ATH_MSG_INFO( "Event Overlay: \t" << ((m_rndmEvtOverlay)?"true":"false"));
  ATH_MSG_INFO( "Masking Channels: \t" << ((m_maskBadChannels)?"true":"false"));
  ATH_MSG_INFO( "Pulse shapes from COOL: \t" << ((m_useCoolPulseShapes)?"true":"false"));
 
  m_inputDigitContainerName = m_inputDigitContainerKey.key();
 
  if (m_rndmEvtOverlay) {
    ATH_MSG_INFO( "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_INFO( "PileUpMergeSvc successfully initialized");
    }
  }
 
  ATH_MSG_VERBOSE("TilePulseForTileMuonReceiver initialization completed");
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isClonable()

virtual bool TilePulseForTileMuonReceiver::isClonable ( ) const

inlinefinaloverridevirtual

Definition at line 91 of file TilePulseForTileMuonReceiver.h.

{ return true; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< 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< 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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::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< 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< 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_adcMax

int TilePulseForTileMuonReceiver::m_adcMax

private

ADC saturation value.

Definition at line 166 of file TilePulseForTileMuonReceiver.h.

m_badChannelsKey

SG::ReadCondHandleKey<TileBadChannels> TilePulseForTileMuonReceiver::m_badChannelsKey

private

Initial value:

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

Name of TileBadChannels in condition store.

Definition at line 144 of file TilePulseForTileMuonReceiver.h.

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

m_binTime0

int TilePulseForTileMuonReceiver::m_binTime0

private

Index of time=0 bin for pulse shape.

Definition at line 173 of file TilePulseForTileMuonReceiver.h.

m_cablingService

const TileCablingService* TilePulseForTileMuonReceiver::m_cablingService

private

TileCabling instance.

Definition at line 162 of file TilePulseForTileMuonReceiver.h.

m_cablingSvc

ServiceHandle<TileCablingSvc> TilePulseForTileMuonReceiver::m_cablingSvc

private

Initial value:

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

Name of Tile cabling service.

Definition at line 116 of file TilePulseForTileMuonReceiver.h.

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

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_emScaleKey

SG::ReadCondHandleKey<TileEMScale> TilePulseForTileMuonReceiver::m_emScaleKey

private

Initial value:

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

Name of TileEMScale in condition store.

Definition at line 132 of file TilePulseForTileMuonReceiver.h.

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

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_hitContainerKey

SG::ReadHandleKey<TileHitContainer> TilePulseForTileMuonReceiver::m_hitContainerKey

private

Initial value:

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

Definition at line 98 of file TilePulseForTileMuonReceiver.h.

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

m_infoName

Gaudi::Property<std::string> TilePulseForTileMuonReceiver::m_infoName {this, "TileInfoName", "TileInfo", "TileInfo object name"}

private

Definition at line 150 of file TilePulseForTileMuonReceiver.h.

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

m_inputDigitContainerKey

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

private

Definition at line 95 of file TilePulseForTileMuonReceiver.h.

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

m_inputDigitContainerName

std::string TilePulseForTileMuonReceiver::m_inputDigitContainerName {""}

private

Definition at line 96 of file TilePulseForTileMuonReceiver.h.

{""};

m_integerDigits

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_integerDigits {this, "IntegerDigits", false, "Round digits (default=false)"}

private

Definition at line 151 of file TilePulseForTileMuonReceiver.h.

{this, "IntegerDigits", false, "Round digits (default=false)"};

m_iTrig

int TilePulseForTileMuonReceiver::m_iTrig

private

Index of the triggering time slice.

Definition at line 165 of file TilePulseForTileMuonReceiver.h.

m_maskBadChannels

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_maskBadChannels {this, "MaskBadChannels", false, "Remove channels tagged bad (default=false)"}

private

Definition at line 152 of file TilePulseForTileMuonReceiver.h.

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

m_mergeSvc

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

private

Definition at line 176 of file TilePulseForTileMuonReceiver.h.

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

m_MuRcvBuildTool

ToolHandle<TileRawChannelBuilderMF> TilePulseForTileMuonReceiver::m_MuRcvBuildTool

private

Initial value:

{this,
        "TileRawChannelBuilderMF", "TileRawChannelBuilderMF", "Reconstruction tool, default: the Matched Filter"}

Definition at line 147 of file TilePulseForTileMuonReceiver.h.

                                                        {this,
        "TileRawChannelBuilderMF", "TileRawChannelBuilderMF", "Reconstruction tool, default: the Matched Filter"};

m_muRcvDigitsContainerKey

SG::WriteHandleKey<TileDigitsContainer> TilePulseForTileMuonReceiver::m_muRcvDigitsContainerKey

private

Initial value:

{this,
        "MuonReceiverDigitsContainer", "MuRcvDigitsCnt", "Output Tile muon receiver digits container key"}

Definition at line 101 of file TilePulseForTileMuonReceiver.h.

                                                                   {this,
        "MuonReceiverDigitsContainer", "MuRcvDigitsCnt", "Output Tile muon receiver digits container key"};

m_muRcvRawChannelContainerKey

SG::WriteHandleKey<TileRawChannelContainer> TilePulseForTileMuonReceiver::m_muRcvRawChannelContainerKey

private

Initial value:

{this,
        "MuonReceiverRawChannelContainer", "MuRcvRawChCnt", "Output Tile muon receiver raw channel container key"}

Definition at line 104 of file TilePulseForTileMuonReceiver.h.

                                                                           {this,
        "MuonReceiverRawChannelContainer", "MuRcvRawChCnt", "Output Tile muon receiver raw channel container key"};

m_nBinsPerX

int TilePulseForTileMuonReceiver::m_nBinsPerX

private

Number of bins per bunch crossing in pulse shape.

Definition at line 172 of file TilePulseForTileMuonReceiver.h.

m_nSamples

int TilePulseForTileMuonReceiver::m_nSamples

private

Number of time slices for each channel.

Definition at line 164 of file TilePulseForTileMuonReceiver.h.

m_nShape

int TilePulseForTileMuonReceiver::m_nShape

private

Number of bins in pulse shape.

Definition at line 171 of file TilePulseForTileMuonReceiver.h.

m_onlyUseContainerName

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}

private

Definition at line 157 of file TilePulseForTileMuonReceiver.h.

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

m_pulseShapeKey

SG::ReadCondHandleKey<TilePulse> TilePulseForTileMuonReceiver::m_pulseShapeKey

private

Initial value:

{this,
        "TilePulseShape", "TileMuRcvPulseShape", "Input Tile Muon Receiver pulse shape"}

Name of TilePulseShape in condition store.

Definition at line 138 of file TilePulseForTileMuonReceiver.h.

                                                  {this,
        "TilePulseShape", "TileMuRcvPulseShape", "Input Tile Muon Receiver pulse shape"};

m_randomStreamName

Gaudi::Property<std::string> TilePulseForTileMuonReceiver::m_randomStreamName {this, "RandomStreamName", "Tile_PulseForTileMuonReceiver", ""}

private

Random Stream Name.

Definition at line 121 of file TilePulseForTileMuonReceiver.h.

{this, "RandomStreamName", "Tile_PulseForTileMuonReceiver", ""};

m_rndmEvtOverlay

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_rndmEvtOverlay {this, "RndmEvtOverlay", false, "Pileup and/or noise added by overlaying random events (default=false)"}

private

Definition at line 156 of file TilePulseForTileMuonReceiver.h.

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

m_rndmSvc

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

private

Random number service to use.

Definition at line 119 of file TilePulseForTileMuonReceiver.h.

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

m_runPeriod

int TilePulseForTileMuonReceiver::m_runPeriod

private

Definition at line 181 of file TilePulseForTileMuonReceiver.h.

m_sampleNoiseKey

SG::ReadCondHandleKey<TileSampleNoise> TilePulseForTileMuonReceiver::m_sampleNoiseKey

private

Initial value:

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

Name of TileSampleNoise in condition store.

Definition at line 126 of file TilePulseForTileMuonReceiver.h.

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

m_samplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> TilePulseForTileMuonReceiver::m_samplingFractionKey

private

Initial value:

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

Name of TileSamplingFraction in condition store.

Definition at line 110 of file TilePulseForTileMuonReceiver.h.

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

m_shapeMuonReceiver

std::vector<double> TilePulseForTileMuonReceiver::m_shapeMuonReceiver

private

Muon receiver pulse shape.

Definition at line 179 of file TilePulseForTileMuonReceiver.h.

m_tileHWID

const TileHWID* TilePulseForTileMuonReceiver::m_tileHWID

private

Definition at line 160 of file TilePulseForTileMuonReceiver.h.

m_tileID

const TileID* TilePulseForTileMuonReceiver::m_tileID

private

Definition at line 159 of file TilePulseForTileMuonReceiver.h.

m_tileInfo

const TileInfo* TilePulseForTileMuonReceiver::m_tileInfo

private

Definition at line 161 of file TilePulseForTileMuonReceiver.h.

m_tileNoise

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_tileNoise {this, "UseCoolNoise", false, "Noise from database (default=false)"}

private

Definition at line 154 of file TilePulseForTileMuonReceiver.h.

{this, "UseCoolNoise", false, "Noise from database (default=false)"};

m_tilePedestal

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_tilePedestal {this, "UseCoolPedestal", false, "Pedestal from database (default=false)"}

private

Definition at line 155 of file TilePulseForTileMuonReceiver.h.

{this, "UseCoolPedestal", false, "Pedestal from database (default=false)"};

m_tileThresh

double TilePulseForTileMuonReceiver::m_tileThresh

private

Actual threshold value.

Definition at line 167 of file TilePulseForTileMuonReceiver.h.

m_timeStep

double TilePulseForTileMuonReceiver::m_timeStep

private

Time step in pulse shape: 25.0 / nBinsPerX.

Definition at line 174 of file TilePulseForTileMuonReceiver.h.

m_useCoolPulseShapes

Gaudi::Property<bool> TilePulseForTileMuonReceiver::m_useCoolPulseShapes {this, "UseCoolPulseShapes", false, "Pulse shapes from database (default=false)"}

private

Definition at line 153 of file TilePulseForTileMuonReceiver.h.

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

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TilePulseForTileMuonReceiver.h
• TilePulseForTileMuonReceiver.cxx