Trig::TrigConfBunchCrossingTool Class Reference

The trigger config implementation of IBunchCrossingTool. More...

#include <TrigConfBunchCrossingTool.h>

Inheritance diagram for Trig::TrigConfBunchCrossingTool:

Collaboration diagram for Trig::TrigConfBunchCrossingTool:

Public Types
enum	BeamType { Beam1 = 0 , Beam2 = 1 , Crossing = 2 }
	Types of the return values of the bcIntensity function. More...
enum	BunchCrossingType {   Empty = 0 , FirstEmpty = 1 , MiddleEmpty = 2 , Single = 100 ,   Front = 200 , Middle = 201 , Tail = 202 , Unpaired = 300 }
	Simplified type for a given bunch crossing. More...
enum	BunchDistanceType { NanoSec , BunchCrossings , FilledBunches }
	Enumeration specifying the units in which to expect the bunch distance type. More...
enum	BunchFillType {   CollidingBunch = 0 , UnpairedBunch = 1 , EmptyBunch = 2 , UnpairedBeam1 = 3 ,   UnpairedBeam2 = 4 }
	Enumeration specifying what kind of bunch to use in the gap functions. More...
typedef unsigned int	bcid_type
	Declare the interface that this class provides.
typedef unsigned int	configid_type
	Declare the interface that this class provides.
Definition of the StoreGate-like object's definition
typedef ServiceHandle< StoreGateSvc >	MetaStore_t
	Type of the metadata store object in Athena.
typedef const ServiceHandle< StoreGateSvc > &	MetaStorePtr_t
	Type of the metadata store pointer in standalone mode.

Public Member Functions
virtual void	print () const
	Print the state of the tool.
virtual StatusCode	sysInitialize ()
	Function initialising the tool in the correct way in Athena.
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
virtual std::vector< int >	configuredBCIDs () const
	Function providing the BCIDs of the configured colliding bunches.
virtual std::vector< int >	configuredUnpairedBCIDsBeam1 () const
	Function providing the BCIDs of the configured unpaired bunches.
virtual std::vector< int >	configuredUnpairedBCIDsBeam2 () const
	Function providing the BCIDs of the configured unpaired bunches.
Functions implementing the IBunchCrossingTool interface
virtual bool	isFilled (bcid_type bcid) const
	The simplest query: Is the bunch crossing filled or not?
virtual bool	isInTrain (bcid_type bcid) const
	Function deciding if a given bunch crossing is in a filled train.
virtual bool	isUnpaired (bcid_type bcid) const
	Function deciding if a given bunch crossing has an unpaired bunch.
virtual bool	isBeam1 (bcid_type bcid) const
	Function deciding if there was a bunch from "beam 1" in this bunch crossing.
virtual bool	isBeam2 (bcid_type bcid) const
	Function deciding if there was a bunch from "beam 2" in this bunch crossing.
virtual float	bcIntensity (bcid_type bcid, BeamType type=Crossing) const
	Function returning the "intensity" of a given bunch crossing.
virtual BunchCrossingType	bcType (bcid_type bcid) const
	Get the type of the specific bunch crossing.
virtual int	distanceFromFront (bcid_type bcid, BunchDistanceType type=NanoSec) const
	The distance of the specific bunch crossing from the front of the train.
virtual int	distanceFromTail (bcid_type bcid, BunchDistanceType type=NanoSec) const
	The distance of the specific bunch crossing from the tail of the train.
virtual int	gapBeforeTrain (bcid_type bcid, BunchDistanceType type=NanoSec) const
	Gap before the train this BCID is in.
virtual int	gapAfterTrain (bcid_type bcid, BunchDistanceType type=NanoSec) const
	Gap after the train this BCID is in.
virtual int	gapBeforeBunch (bcid_type bcid, BunchDistanceType dtype=NanoSec, BunchFillType ftype=CollidingBunch) const
	Gap before a particular bunch.
virtual int	gapAfterBunch (bcid_type bcid, BunchDistanceType dtype=NanoSec, BunchFillType ftype=CollidingBunch) const
	Gap after a particular bunch.
virtual std::vector< bool >	bunchesInFront (bcid_type bcid, int bunches=10) const
	Function returning whether the previous bunches were filled, and how.
virtual std::vector< bool >	bunchesAfter (bcid_type bcid=0, int bunches=10) const
	Function returning whether the following bunches were filled, and how.
virtual std::vector< float >	bunchIntInFront (bcid_type bcid, int bunches=10, BeamType type=Crossing) const
	Function returning the intensities of the bunch crossings before the reference.
virtual std::vector< float >	bunchIntAfter (bcid_type bcid, int bunches=10, BeamType type=Crossing) const
	Function returning the intensities of the bunch crossings after the reference.
virtual unsigned int	numberOfFilledBunches () const
	Get the number of filled bunches in the current configuration.
virtual unsigned int	numberOfUnpairedBunches () const
	Get the number of unpaired bunches in the current configuration.
virtual unsigned int	numberOfBunchTrains () const
	Get the number of the bunch trains in the current configuration.
virtual int	bunchTrainSpacing (BunchDistanceType type=NanoSec) const
	Get the bunch spacing in the trains.
Functions providing access to the input/output metadata
MetaStorePtr_t	inputMetaStore () const
	Accessor for the input metadata store.
MetaStorePtr_t	outputMetaStore () const
	Accessor for the output metadata store.
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
virtual StatusCode	beginEvent ()
	Function called when a new event is loaded.
StatusCode	loadSingleBunches (const std::vector< int > &bunches, const std::vector< float > &bunch_int1=std::vector< float >(), const std::vector< float > &bunch_int2=std::vector< float >())
	Interpret the configuration for single bunches.
StatusCode	loadBunchTrains (const std::vector< int > &bunches, const std::vector< float > &bunch_int1=std::vector< float >(), const std::vector< float > &bunch_int2=std::vector< float >())
	Interpret the configuration for bunch trains.
StatusCode	loadUnpairedBunches (const std::vector< int > &beam1, const std::vector< int > &beam2, const std::vector< float > &bunch_int1=std::vector< float >(), const std::vector< float > &bunch_int2=std::vector< float >())
	Interpret the configuration for unpaired bunches.
void	printConfig () const
	Function printing the configuration of the tool.
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.
Callback functions helping in metadata reading/writing
void	setUseIncidents (const bool flag)
virtual void	handle (const Incident &inc)
	Function receiving incidents from IncidentSvc/Event.
virtual StatusCode	beginInputFile ()
	Function called when a new input file is opened.
virtual StatusCode	endInputFile ()
	Function called when the currently open input file got completely processed.
virtual StatusCode	metaDataStop ()
	Function called when the tool should write out its metadata.

Protected Attributes
Variables holding the decoded bunch structure
std::set< Trig::BunchCrossing >	m_filledBunches
	List of colliding bunches.
std::set< Trig::BunchCrossing >	m_singleBunches
	Internal list of single bunches.
std::set< Trig::BunchCrossing >	m_unpairedBunches
	Internal list of unpaired bunches.
std::set< Trig::BunchTrain >	m_bunchTrains
	Internal list of bunch trains.
Configurable tool properties
int	m_maxBunchSpacing
	The maximum bunch spacing that the tool should consider.
int	m_frontLength
	Length of the "front" of a bunch train.
int	m_tailLength
	Length of the "tail" of a bunch train.

Static Protected Attributes
static const std::string	BUNCH_CONFIG_INCIDENT_NAME = "BunchConfig"
	Type name for the incident that such tools should emit.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual ASG_TOOL_CLASS2(TrigConfBunchCrossingTool, Trig::IBunchCrossingTool, Trig::IBunchCrossingConfProvider) public StatusCode	initialize ()
	Create a proper constructor for Athena.
virtual configid_type	configID () const
	Unique identifier for the current configuration.
virtual std::vector< float >	configuredIntensitiesBeam1 () const
	Override the default implementation because this tool doesn't provide this info.
virtual std::vector< float >	configuredIntensitiesBeam2 () const
	Override the default implementation because this tool doesn't provide this info.
virtual std::vector< float >	configuredUnpairedIntensitiesBeam1 () const
	Override the default implementation because this tool doesn't provide this info.
virtual std::vector< float >	configuredUnpairedIntensitiesBeam2 () const
	Override the default implementation because this tool doesn't provide this info.
StatusCode	loadConfig ()
	Make sure that the latest/correct configuration is loaded.
void	printBunchGroups (const TrigConf::IILVL1ConfigSvc *svc) const
	Print the "raw" configuration for debugging.
int	bunchSpacing (const std::vector< int > &bunches) const
	Get the apparent bunch spacing in the current configuration.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
unsigned int	m_bgId {0}
	DB ID of the BunchGroups settings which was loaded last.
ServiceHandle< TrigConf::ILVL1ConfigSvc >	m_configSvc
	The config service handle.
ToolHandle< TrigConf::ITrigConfigTool >	m_configTool
	The config tool handle.
MetaStore_t	m_inputMetaStore
	Object accessing the input metadata store.
MetaStore_t	m_outputMetaStore
	Object accessing the output metadata store.
bool	m_beginInputFileCalled
	Flag helping to discover when the tool misses the opening of the first input file.
bool	m_useIncidents
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

The trigger config implementation of IBunchCrossingTool.

This implementation should be used primarily to get information about the bunch pattern for data files. It retrieves the bunch pattern configuration using the trigger configuration service. So in principle it can itself get the configuration from a few different places. (Currently TrigConf::LVL1ConfigSvc and TrigConf::DSConfigSvc provide this information.)

It also acts as a bunch crossing configuration provider, implementing the Trig::IBunchCrossingConfProvider interface.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 44 of file TrigConfBunchCrossingTool.h.

Member Typedef Documentation

bcid_type

typedef unsigned int Trig::IBunchCrossingTool::bcid_type

inherited

Declare the interface that this class provides.

Convenience type definition

Definition at line 47 of file IBunchCrossingTool.h.

configid_type

typedef unsigned int Trig::IBunchCrossingConfProvider::configid_type

inherited

Declare the interface that this class provides.

Type for the unique identifier

Definition at line 60 of file IBunchCrossingConfProvider.h.

MetaStore_t

typedef ServiceHandle< StoreGateSvc > asg::AsgMetadataTool::MetaStore_t

inherited

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

MetaStorePtr_t

typedef const ServiceHandle< StoreGateSvc >& asg::AsgMetadataTool::MetaStorePtr_t

inherited

Type of the metadata store pointer in standalone mode.

Definition at line 68 of file AsgMetadataTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

BeamType

enum Trig::IBunchCrossingTool::BeamType

inherited

Types of the return values of the bcIntensity function.

The different information sources provide the "bunch intensity" information in quite different ways, and the information can mean different things actually. This enumeration is used to specify what exact type of information the user is looking for.

Enumerator
Beam1	The returned intensity should be for "beam 1".
Beam2	The returned intensity should be for "beam 2".
Crossing	The returned intensity should describe the BC.

Definition at line 118 of file IBunchCrossingTool.h.

                    {
         Beam1    = 0, 
         Beam2    = 1, 
         Crossing = 2  
      };

BunchCrossingType

enum Trig::IBunchCrossingTool::BunchCrossingType

inherited

Simplified type for a given bunch crossing.

This enumeration can specify what kind of bunch crossing one BCID belongs to. The types could easily be extended later on.

Enumerator
Empty	An empty bunch far away from filled bunches.
FirstEmpty	The first empty bunch after a train.
MiddleEmpty	An empty BCID in the middle of a train.
Single	This is a filled, single bunch (not in a train).
Front	The BCID belongs to the first few bunches in a train.
Middle	The BCID belongs to the middle bunches in a train.
Tail	The BCID belongs to the last few bunces in a train.
Unpaired	This is an unpaired bunch (either beam1 or beam2).

Definition at line 145 of file IBunchCrossingTool.h.

                             {
         Empty = 0, 
         FirstEmpty = 1, 
         MiddleEmpty = 2, 
         Single = 100, 
         Front = 200, 
         Middle = 201, 
         Tail = 202, 
         Unpaired = 300 
      };

BunchDistanceType

enum Trig::IBunchCrossingTool::BunchDistanceType

inherited

Enumeration specifying the units in which to expect the bunch distance type.

To make it clear for the following functions what units to interpret their return values in, it is possible to request their return values in different units.

Enumerator
NanoSec	Distance in nanoseconds.
BunchCrossings	Distance in units of 25 nanoseconds.
FilledBunches	Distance in units of filled bunches (depends on filling scheme).

Definition at line 174 of file IBunchCrossingTool.h.

                             {
         NanoSec, 
         BunchCrossings, 
         FilledBunches
      };

BunchFillType

enum Trig::IBunchCrossingTool::BunchFillType

inherited

Enumeration specifying what kind of bunch to use in the gap functions.

The following functions can be used to calculate the gap before and after a specific BCID to some other bunch type. The gap can actually be wrt. two different types of bunches. The user may be interested between the space of two filled bunches, the space between an unpaired bunch and the previous filled bunch, the space between two unpaired bunches, or the space between a filled bunch and the previous unpaired bunch.

The empty type is just put here for completeness. Maybe once we'll be using 25 ns spacing in the bunch trains, this will be a useful parameter as well.

This enumeration helps in answeing all of these questions.

Enumerator
CollidingBunch	The gap should be calculated wrt. the closest colling bunch.
UnpairedBunch	The gap should be calculated wrt. the closest unpaired bunch.
EmptyBunch	The gap should be calculated wrt. the closest empty bunch.
UnpairedBeam1	The gap should be calculated wrt. the closest unpaired bunch from beam 1
UnpairedBeam2	The gap should be calculated wrt. the closest unpaired bunch from beam 2

Definition at line 274 of file IBunchCrossingTool.h.

                         {
         CollidingBunch = 0,
         UnpairedBunch  = 1,
         EmptyBunch     = 2,
         UnpairedBeam1  = 3,
         UnpairedBeam2  = 4
      };

Member Function Documentation

bcIntensity()

float Trig::BunchCrossingToolBase::bcIntensity ( bcid_type bcid, BeamType type = Crossing ) const

virtualinherited

Function returning the "intensity" of a given bunch crossing.

Implements Trig::IBunchCrossingTool.

Definition at line 108 of file BunchCrossingToolBase.cxx.

                                                                   {
 
      // Check if this is a colliding bunch:
      std::set< BunchCrossing >::const_iterator itr;
      if( ( itr = m_filledBunches.find( bcid ) ) != m_filledBunches.end() ) {
         switch( type ) {
         case Crossing:
            if( itr->intensityBeam2() > 0.001 ) {
               ATH_MSG_WARNING( "Crossing intensity not available, ask for "
                                << "separate beam intensities instead" );
               return 0.0;
            } else {
               return itr->intensityBeam1();
            }
         case Beam1:
            if( std::abs( itr->intensityBeam2() ) < 0.001 ) {
               ATH_MSG_WARNING( "Separate beam intensities not available, ask "
                                << "for the crossing intensity instead" );
               return 0.0;
            } else {
               return itr->intensityBeam1();
            }
            break;
         case Beam2:
            return itr->intensityBeam2();
            break;
         default:
            ATH_MSG_ERROR( "Unknown intensity type requested (" << type
                           << ")" );
            return -1.0;
         }
      }
 
      // Check if this is an unpaired bunch:
      if( ( itr = m_unpairedBunches.find( bcid ) ) !=
          m_unpairedBunches.end() ) {
         switch( type ) {
         case Beam1:
            return itr->intensityBeam1();
            break;
         case Beam2:
            return itr->intensityBeam2();
            break;
         case Crossing:
            ATH_MSG_WARNING( "Crossing intensity requested for unpaired bunch ("
                             << "bcid=" << bcid << ")" );
            return 0.0;
         default:
            ATH_MSG_ERROR( "Unknown intensity type requested (" << type
                           << ")" );
            return -1.0;
         }
      }
 
      // If neither, then its intensity is 0.0 by definition:
      return 0.0;
   }

bcType()

IBunchCrossingTool::BunchCrossingType Trig::BunchCrossingToolBase::bcType ( bcid_type bcid ) const

virtualinherited

Get the type of the specific bunch crossing.

Implements Trig::IBunchCrossingTool.

Definition at line 168 of file BunchCrossingToolBase.cxx.

                                                       {
 
      // First the obvious check:
      if( ! isFilled( bcid ) ) {
         // Check if it's an unpaired bunch:
         if( isUnpaired( bcid ) ) {
            return Unpaired;
         }
         // If the previous bunch crossing is the tail of a bunch train:
         if( ! distanceFromTail( bcid - 1, BunchCrossings ) ) {
            return FirstEmpty;
         }
         // Check if it's in the middle of a bunch train:
         std::set< BunchTrain >::const_iterator itr = m_bunchTrains.begin();
         std::set< BunchTrain >::const_iterator end = m_bunchTrains.end();
         for( ; itr != end; ++itr ) {
            if( itr->isInside( bcid ) ) {
               return MiddleEmpty;
            }
         }
         // If none of the above are true, it has to be a "simple" empty bunch:
         return Empty;
      }
 
      // Now we know that the bunch has to be a filled one...
 
      // If it's not in a train, it has to be a single filled bunch:
      if( ! isInTrain( bcid ) ) return Single;
 
      // Let's check if it is close to the front of a bunch train:
      int distance = distanceFromFront( bcid, NanoSec );
      if( ( distance >= 0 ) && ( distance <= m_frontLength ) ) {
         return Front;
      }
      // Now let's check if it's close to the tail of a bunch train:
      distance = distanceFromTail( bcid, NanoSec );
      if( ( distance >= 0 ) && ( distance <= m_tailLength ) ) {
         return Tail;
      }
 
      // If none of the above are true, it has to be in the middle of a train:
      return Middle;
   }

beginEvent()

StatusCode Trig::TrigConfBunchCrossingTool::beginEvent ( )

protectedvirtual

Function called when a new event is loaded.

Reimplemented from asg::AsgMetadataTool.

Definition at line 83 of file TrigConfBunchCrossingTool.cxx.

                                                    {
 
      // Simply call the function doing the heavy lifting:
      ATH_CHECK( loadConfig() );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )

protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, BookkeeperDumperTool, BookkeeperTool, PMGTools::PMGTruthWeightTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, TauAnalysisTools::TauSmearingTool, Trig::TrigDecisionTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 185 of file AsgMetadataTool.cxx.

                                              {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

bunchesAfter()

std::vector< bool > Trig::BunchCrossingToolBase::bunchesAfter ( bcid_type bcid = 0, int bunches = 10 ) const

virtualinherited

Function returning whether the following bunches were filled, and how.

Implements Trig::IBunchCrossingTool.

Definition at line 701 of file BunchCrossingToolBase.cxx.

                                                            {
 
      // The only thing we have to be careful about is the bunches near the
      // "turnover" region of the BCIDs. That's why I use the BunchCrossing
      // class here:
      std::vector< bool > result;
      for( int i = 0; i < bunches; ++i ) {
         result.push_back( isFilled( BunchCrossing( bcid ) +
                                     BunchCrossing( i ) ) );
      }
 
      return result;
   }

bunchesInFront()

std::vector< bool > Trig::BunchCrossingToolBase::bunchesInFront ( bcid_type bcid, int bunches = 10 ) const

virtualinherited

Function returning whether the previous bunches were filled, and how.

Implements Trig::IBunchCrossingTool.

Definition at line 685 of file BunchCrossingToolBase.cxx.

                                                              {
 
      // The only thing we have to be careful about is the bunches near the
      // "turnover" region of the BCIDs. That's why I use the BunchCrossing
      // class here:
      std::vector< bool > result;
      for( int i = 0; i < bunches; ++i ) {
         result.push_back( isFilled( BunchCrossing( bcid ) -
                                     BunchCrossing( i ) ) );
      }
 
      return result;
   }

bunchIntAfter()

std::vector< float > Trig::BunchCrossingToolBase::bunchIntAfter ( bcid_type bcid, int bunches = 10, BeamType type = Crossing ) const

virtualinherited

Function returning the intensities of the bunch crossings after the reference.

Implements Trig::IBunchCrossingTool.

Definition at line 748 of file BunchCrossingToolBase.cxx.

                                                               {
 
      std::vector< float > result;
      for( int i = 0; i < bunches; ++i ) {
         std::set< BunchCrossing >::const_iterator itr =
            m_filledBunches.find( BunchCrossing( bcid ) + BunchCrossing( i ) );
         if( itr != m_filledBunches.end() ) {
            switch( type ) {
            case Beam1:
            case Crossing:
               result.push_back( itr->intensityBeam1() );
               break;
            case Beam2:
               result.push_back( itr->intensityBeam2() );
               break;
            default:
               ATH_MSG_ERROR( "Unknown intensity type requested ("
                              << type << ")" );
               return result;
            }
         } else {
            result.push_back( 0.0 );
         }
      }
 
      return result;
   }

bunchIntInFront()

std::vector< float > Trig::BunchCrossingToolBase::bunchIntInFront ( bcid_type bcid, int bunches = 10, BeamType type = Crossing ) const

virtualinherited

Function returning the intensities of the bunch crossings before the reference.

Implements Trig::IBunchCrossingTool.

Definition at line 717 of file BunchCrossingToolBase.cxx.

                                                                 {
 
      std::vector< float > result;
      for( int i = 0; i < bunches; ++i ) {
         std::set< BunchCrossing >::const_iterator itr =
            m_filledBunches.find( BunchCrossing( bcid ) - BunchCrossing( i ) );
         if( itr != m_filledBunches.end() ) {
            switch( type ) {
            case Beam1:
            case Crossing:
               result.push_back( itr->intensityBeam1() );
               break;
            case Beam2:
               result.push_back( itr->intensityBeam2() );
               break;
            default:
               ATH_MSG_ERROR( "Unknown intensity type requested ("
                              << type << ")" );
               return result;
            }
         } else {
            result.push_back( 0.0 );
         }
      }
 
      return result;
   }

bunchSpacing()

int Trig::BunchCrossingToolBase::bunchSpacing ( const std::vector< int > & bunches ) const

privateinherited

Get the apparent bunch spacing in the current configuration.

This function tries to figure out what's the right bunch spacing for the current configuration, before the code would try to properly interpret the configuration.

This allows us to set a "MaxBunchSpacing" property of a relatively large number, but still be able to interpret configurations with very small gaps between bunch trains. (Like the 8b4e 2017 configurations.)

Parameters

bunches

The filled bunches in the current configuration

Returns

The apparent bunch spacing of the configuration in bunch crossings

Definition at line 1192 of file BunchCrossingToolBase.cxx.

                                                         {
 
      // The maximum BC spacing to start from.
      const int maxSpacing = m_maxBunchSpacing / BunchCrossing::BUNCH_SPACING;
 
      // Iterate downwards from the maximum spacing, searching for the minimum
      // spacing with which bunches exist.
      int result = maxSpacing;
      for( ; result > 0; --result ) {
 
         // Test how many bunches have neighbors inside of the current window.
         const int nbunches =
            std::count_if( bunches.begin(), bunches.end(),
                           count_bunch_neighbors( bunches, result ) );
         ATH_MSG_VERBOSE( "Number of bunches with " << result
                          << " BC neighbors: " << nbunches );
 
         // If none of them do, then we're finished.
         if( ! nbunches ) {
            // If we're not at the max spacing anymore, then it means that in
            // the previous step there were still bunches with neighbors in this
            // window. That's the spacing we need then.
            //
            // But if we're still at the maximum spacing, then let's just keep
            // that as the final answer.
            if( result != maxSpacing ) {
               ++result;
            }
            break;
         }
      }
      // If we went down to 0, then the right answer is 1. This is just how this
      // algorithm works...
      if( result == 0 ) {
         result = 1;
      }
      ATH_MSG_DEBUG( "Bunch spacing: " << result << " BCs" );
 
      // Return the smallest spacing found:
      return result;
   }

bunchTrainSpacing()

int Trig::BunchCrossingToolBase::bunchTrainSpacing ( BunchDistanceType type = NanoSec ) const

virtualinherited

Get the bunch spacing in the trains.

Implements Trig::IBunchCrossingTool.

Definition at line 794 of file BunchCrossingToolBase.cxx.

                                                                          {
 
      // Check if there are bunch trains in the current configurations:
      if( m_bunchTrains.size() ) {
         switch( type ) {
         case NanoSec:
            return m_bunchTrains.begin()->spacing();
            break;
         case BunchCrossings:
            return ( m_bunchTrains.begin()->spacing() / 
                     BunchCrossing::BUNCH_SPACING );
            break;
         case FilledBunches:
            ATH_MSG_ERROR( "Function should not be called with argument: "
                           "FilledBunches" );
            return -1;
            break;
         default:
            ATH_MSG_ERROR( "Function called with unknown argument: " << type );
            return -1;
         }
      } else {
         // Return -1 if there are no bunch trains in the configuration:
         return -1;
      }
 
      ATH_MSG_FATAL( "The code should never reach this line. Check the code!" );
      return -1;
   }

configID()

IBunchCrossingConfProvider::configid_type Trig::TrigConfBunchCrossingTool::configID ( ) const

privatevirtual

Unique identifier for the current configuration.

This specialization of the function just returns the BGKey of the currently loaded configuration.

This is the simplest implementation for this function...

Implements Trig::IBunchCrossingConfProvider.

Definition at line 97 of file TrigConfBunchCrossingTool.cxx.

                                             {
 
      return static_cast< configid_type >( m_bgId );
   }

configuredBCIDs()

std::vector< int > Trig::BunchCrossingConfProviderBase::configuredBCIDs ( ) const

virtualinherited

Function providing the BCIDs of the configured colliding bunches.

The implementation just loops over all the possible BCIDs and puts the IDs of the ones which are reported to be filled, into the output vector.

See also

BunchCrossingConfProviderBase::configuredIntensitiesBeam1()

BunchCrossingConfProviderBase::configuredIntensitiesBeam2()

Implements Trig::IBunchCrossingConfProvider.

Definition at line 28 of file BunchCrossingConfProviderBase.cxx.

                                                        {
 
      std::vector< int > bunches;
      for( int i = 0; i < BunchCrossing::MAX_BCID; ++i ) {
         if( isFilled( i ) ) {
            bunches.push_back( i );
         }
      }
 
      return bunches;
   }

configuredIntensitiesBeam1()

std::vector< float > Trig::TrigConfBunchCrossingTool::configuredIntensitiesBeam1 ( ) const

privatevirtual

Override the default implementation because this tool doesn't provide this info.

This function will always return an empty vector, because this tool doesn't provide this sort of information.

While saving the default 1.0 values for all the filled bunches would have the same result right now, the tools may handle the absence of the intensity information in different ways in the future.

Returns

An empty vector

Reimplemented from Trig::BunchCrossingConfProviderBase.

Definition at line 112 of file TrigConfBunchCrossingTool.cxx.

                                                               {
 
      return std::vector< float >();
   }

configuredIntensitiesBeam2()

std::vector< float > Trig::TrigConfBunchCrossingTool::configuredIntensitiesBeam2 ( ) const

privatevirtual

Override the default implementation because this tool doesn't provide this info.

This function will always return an empty vector, because this tool doesn't provide this sort of information.

While saving the default 1.0 values for all the filled bunches would have the same result right now, the tools may handle the absence of the intensity information in different ways in the future.

Returns

An empty vector

Reimplemented from Trig::BunchCrossingConfProviderBase.

Definition at line 127 of file TrigConfBunchCrossingTool.cxx.

                                                               {
 
      return std::vector< float >();
   }

configuredUnpairedBCIDsBeam1()

std::vector< int > Trig::BunchCrossingConfProviderBase::configuredUnpairedBCIDsBeam1 ( ) const

virtualinherited

Function providing the BCIDs of the configured unpaired bunches.

The implementation just loops over all the possible BCIDs and puts the IDs of the ones which are reported to be unpaired, into the output vector.

See also

BunchCrossingConfProviderBase::configuredUnpairedIntensitiesBeam1()

Implements Trig::IBunchCrossingConfProvider.

Definition at line 88 of file BunchCrossingConfProviderBase.cxx.

                                                                     {
 
      std::vector< int > bunches;
      for( int i = 0; i < BunchCrossing::MAX_BCID; ++i ) {
         if( isUnpaired( i ) && isBeam1( i ) ) {
            bunches.push_back( i );
         }
      }
 
      return bunches;
   }

configuredUnpairedBCIDsBeam2()

std::vector< int > Trig::BunchCrossingConfProviderBase::configuredUnpairedBCIDsBeam2 ( ) const

virtualinherited

Function providing the BCIDs of the configured unpaired bunches.

The implementation just loops over all the possible BCIDs and puts the IDs of the ones which are reported to be unpaired, into the output vector.

See also

BunchCrossingConfProviderBase::configuredUnpairedIntensitiesBeam2()

Implements Trig::IBunchCrossingConfProvider.

Definition at line 108 of file BunchCrossingConfProviderBase.cxx.

                                                                     {
 
      std::vector< int > bunches;
      for( int i = 0; i < BunchCrossing::MAX_BCID; ++i ) {
         if( isUnpaired( i ) && isBeam2( i ) ) {
            bunches.push_back( i );
         }
      }
 
      return bunches;
   }

configuredUnpairedIntensitiesBeam1()

std::vector< float > Trig::TrigConfBunchCrossingTool::configuredUnpairedIntensitiesBeam1 ( ) const

privatevirtual

Override the default implementation because this tool doesn't provide this info.

This function will always return an empty vector, because this tool doesn't provide this sort of information.

While saving the default 1.0 values for all the unpaired bunches would have the same result right now, the tools may handle the absence of the intensity information in different ways in the future.

Returns

An empty vector

Reimplemented from Trig::BunchCrossingConfProviderBase.

Definition at line 142 of file TrigConfBunchCrossingTool.cxx.

                                                                       {
 
      return std::vector< float >();
   }

configuredUnpairedIntensitiesBeam2()

std::vector< float > Trig::TrigConfBunchCrossingTool::configuredUnpairedIntensitiesBeam2 ( ) const

privatevirtual

Override the default implementation because this tool doesn't provide this info.

This function will always return an empty vector, because this tool doesn't provide this sort of information.

While saving the default 1.0 values for all the unpaired bunches would have the same result right now, the tools may handle the absence of the intensity information in different ways in the future.

Returns

An empty vector

Reimplemented from Trig::BunchCrossingConfProviderBase.

Definition at line 157 of file TrigConfBunchCrossingTool.cxx.

                                                                       {
 
      return std::vector< float >();
   }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

distanceFromFront()

int Trig::BunchCrossingToolBase::distanceFromFront ( bcid_type bcid, BunchDistanceType type = NanoSec ) const

virtualinherited

The distance of the specific bunch crossing from the front of the train.

This is one of the most tricky functions of this class.

When the user wants to ask the distance of a bunch crossing from the front of its train in units of nano seconds or bunch crossings, the main part of the logic is propagated to the algebra defined for the BunchCrossing class.

But when the user wants to know the distance in terms of filled bunches, the code has to treat 3 different bunch train configurations:

• First is when the bunch train doesn't spread across the "BCID turnover". The code in this case just has to see how many steps it is from bunchtrain->begin().
• If the bunch train spreads across the "BCID turnover", and the bcid is after BCID==0, the code has to count the filled bunches from bunchtrain->train_front() to bunchtrain->end(), plus the filled bunches from bunchtrain->begin() to the bcid in question.
• If the bunch train spreads across the "BCID turnover", and the bcid is "before" BCID==0, the code has to count the filled bunches from bunchtrain->train_front() to the bcid in question.

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

The distance of the bcid in question from the front of its bunch train

Implements Trig::IBunchCrossingTool.

Definition at line 241 of file BunchCrossingToolBase.cxx.

                                                                            {
 
      // Look for this BCID in the list of bunch trains:
      std::set< BunchTrain >::const_iterator itr = m_bunchTrains.begin();
      std::set< BunchTrain >::const_iterator end = m_bunchTrains.end();
      for( ; itr != end; ++itr ) {
         BunchTrain::const_iterator element;
         if( ( element = itr->find( bcid ) ) != itr->end() ) {
            switch( type ) {
 
            case NanoSec:
               return BunchCrossing::BUNCH_SPACING * ( BunchCrossing( bcid ) -
                                                       *( itr->train_front() ) );
               break;
            case BunchCrossings:
               return ( BunchCrossing( bcid ) - *( itr->train_front() ) );
               break;
            case FilledBunches:
               if( *( itr->train_front() ) > *( itr->train_back() ) ) {
                  if( BunchCrossing( bcid ) <= *( itr->train_back() ) ) {
                     return ( std::count_if( itr->begin(), element,
                                             std::bind( std::not_equal_to< BunchCrossing >(),
                                                        *element, std::placeholders::_1 ) ) +
                              std::count_if( itr->train_front(), itr->end(),
                                             std::bind( std::not_equal_to< BunchCrossing >(),
                                                        *element, std::placeholders::_1 ) ) );
                  } else {
                     return std::count_if( itr->train_front(), element,
                                           std::bind( std::not_equal_to< BunchCrossing >(),
                                                      *element, std::placeholders::_1 ) );
                  }
               } else {
                  return std::count_if( itr->begin(), element,
                                        std::bind( std::not_equal_to< BunchCrossing >(),
                                                   *element, std::placeholders::_1 ) );
               }
               break;
            default:
               ATH_MSG_ERROR( "BunchDistanceType not understood!" );
               return -1;
            }
         }
      }
 
      // If the bunch crossing is not part of a train:
      return -1;
   }

distanceFromTail()

int Trig::BunchCrossingToolBase::distanceFromTail ( bcid_type bcid, BunchDistanceType type = NanoSec ) const

virtualinherited

The distance of the specific bunch crossing from the tail of the train.

This is one of the most tricky functions of this class.

When the user wants to ask the distance of a bunch crossing from the tail of its train in units of nano seconds or bunch crossings, the main part of the logic is propagated to the algebra defined for the BunchCrossing class.

But when the user wants to know the distance in terms of filled bunches, the code has to treat 3 different bunch train configurations:

• First is when the bunch train doesn't spread across the "BCID turnover". The code in this case just has to see how many steps it is from bunchtrain->end().
• If the bunch train spreads across the "BCID turnover", and the bcid is "before" BCID==0, the code has to count the filled bunches from the bcid in question to bunchtrain->end(), plus the filled bunches from bunchtrain->begin() to bunchtrain->train_back().
• If the bunch train spreads across the "BCID turnover", and the bcid is after BCID==0, the code has to count the filled bunches from the bcid in question to bunchtrain->train_back().

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

The distance of the bcid in question from the tail of its bunch train

Implements Trig::IBunchCrossingTool.

Definition at line 318 of file BunchCrossingToolBase.cxx.

                                                                               {
 
      // Look for this BCID in the list of bunch trains:
      std::set< BunchTrain >::const_iterator itr = m_bunchTrains.begin();
      std::set< BunchTrain >::const_iterator end = m_bunchTrains.end();
      for( ; itr != end; ++itr ) {
         BunchTrain::const_iterator element;
         if( ( element = itr->find( bcid ) ) != itr->end() ) {
            switch( type ) {
 
            case NanoSec:
               return BunchCrossing::BUNCH_SPACING * ( *( itr->train_back() ) -
                                                       BunchCrossing( bcid ) );
               break;
            case BunchCrossings:
               return ( *( itr->train_back() ) - BunchCrossing( bcid ) );
               break;
            case FilledBunches:
               if( *( itr->train_front() ) > *( itr->train_back() ) ) {
                  if( BunchCrossing( bcid ) > *( itr->train_back() ) ) {
                     return ( std::count_if( element, itr->end(),
                                             std::bind( std::not_equal_to< BunchCrossing >(),
                                                        *element, std::placeholders::_1 ) ) +
                              std::count_if( itr->begin(), ++( itr->train_back() ),
                                             std::bind( std::not_equal_to< BunchCrossing >(),
                                                        *element, std::placeholders::_1 ) ) );
                  } else {
                     return std::count_if( element, ++( itr->train_back() ),
                                           std::bind( std::not_equal_to< BunchCrossing >(),
                                                      *element, std::placeholders::_1 ) );
                  }
               } else {
                  return std::count_if( element, itr->end(),
                                        std::bind( std::not_equal_to< BunchCrossing >(),
                                                   *element, std::placeholders::_1 ) );
               }
               break;
            default:
               ATH_MSG_ERROR( "BunchDistanceType not understood!" );
               return -1;
            }
         }
      }
 
      // If the bunch crossing is not part of a train:
      return -1;
   }

endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )

protectedvirtualinherited

Function called when the currently open input file got completely processed.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in BookkeeperDumperTool, BookkeeperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 193 of file AsgMetadataTool.cxx.

                                            {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

gapAfterBunch()

int Trig::BunchCrossingToolBase::gapAfterBunch ( bcid_type bcid, BunchDistanceType dtype = NanoSec, BunchFillType ftype = CollidingBunch ) const

virtualinherited

Gap after a particular bunch.

The function creates a smart BunchCrossing out of the BCID provided, then it goes looking for the next bunch crossing of the specified type.

Finally it just calculates the distance between the two bunch crossings in the requested units. It can return the size of the gap either in nanoseconds or in BCIDs (25 ns steps).

Parameters

bcid	The bcid that should be investigated
dtype	The type of the requested return value
ftype	The type of the previous bunch to consider

Returns

The gap after the specified bcid

Implements Trig::IBunchCrossingTool.

Definition at line 575 of file BunchCrossingToolBase.cxx.

                                                                         {
 
      // Construct this "smart" BCID:
      const BunchCrossing bunch( bcid );
 
      // Search for the first next bunch that fulfills the requirement:
      BunchCrossing next_bunch( bunch );
      ++next_bunch;
      int loop_counter = 0;
      switch( ftype ) {
 
      case CollidingBunch:
         // There should always be filled bunches in the configuration, but
         // let's make sure that we don't get into an endless loop:
         while( ( ! isFilled( next_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            ++next_bunch;
            ++loop_counter;
         }
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            ATH_MSG_ERROR( "Failed to calculate gap after BCID "
                           << bcid << " to a filled bunch! This shouldn't have "
                           << "happened!" );
            return -1;
         }
         break;
      case UnpairedBunch:
         // There are no unpaired bunches in every configuration, so make sure
         // we don't get into an endless loop:
         while( ( ! isUnpaired( next_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            ++next_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches in the configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case UnpairedBeam1:
         // There are no unpaired bunches from beam 1 in every configuration, so
         // make sure we don't get into an endless loop:
         while( ( ! ( isUnpaired( next_bunch ) && isBeam1( next_bunch ) ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            ++next_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches from beam 1 in the
         // configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case UnpairedBeam2:
         // There are no unpaired bunches from beam 2 in every configuration, so
         // make sure we don't get into an endless loop:
         while( ( ! ( isUnpaired( next_bunch ) && isBeam2( next_bunch ) ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            ++next_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches from beam 2 in the
         // configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case EmptyBunch:
         // There should always be empty bunches in the configuration, but let's
         // make sure that we don't get into an endless loop:
         while( ( isFilled( next_bunch ) || isUnpaired( next_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            ++next_bunch;
            ++loop_counter;
         }
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            ATH_MSG_ERROR( "Failed to calculate gap after BCID "
                           << bcid << " to an empty bunch! This shouldn't have "
                           << "happened!" );
            return -1;
         }
         break;
      default:
         ATH_MSG_ERROR( "Unknown bunch fill type specified: "
                        << ftype );
         return -1;
      }
 
      // Now return the results:
      switch( dtype ) {
 
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING * bunch.gapTo( next_bunch );
         break;
      case BunchCrossings:
         return bunch.gapTo( next_bunch );
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapBeforeBunch" );
         return -1;
      }
 
      // This should actually never be reached:
      return -1;
   }

gapAfterTrain()

int Trig::BunchCrossingToolBase::gapAfterTrain ( bcid_type bcid, BunchDistanceType type = NanoSec ) const

virtualinherited

Gap after the train this BCID is in.

The function first finds the train that the specified BCID is in.

Then it calculates the size of the gap after this train. It can return the size of the gap either in nanoseconds or in BCIDs (25 ns steps).

Parameters

bcid	The bcid whose train should be investigated
type	The type of the requested return value

Returns

The gap after the train of the specified bcid

Implements Trig::IBunchCrossingTool.

Definition at line 414 of file BunchCrossingToolBase.cxx.

                                                                                          {
      const auto train = std::ranges::find_if(m_bunchTrains,
          [bcid](const BunchTrain& bunchTrain) {
          return bunchTrain.contains(bcid);
      });
      // If we didn't find this BCID in a train, let's return right away:
      if( train == m_bunchTrains.end() ) {
         return -1;
      }
      // Search for the first filled bunch after the back of this train:
      BunchCrossing train_front = *( train->train_back() );
      do {++train_front; } while (!isFilled(train_front));
      const auto dist = train_front.distance(*train->train_back());
      // Now return the results:
      switch( type ) {
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING * dist;
         break;
      case BunchCrossings:
         return dist;
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapAfterTrain" );
         return -1;
      }
   }

gapBeforeBunch()

int Trig::BunchCrossingToolBase::gapBeforeBunch ( bcid_type bcid, BunchDistanceType dtype = NanoSec, BunchFillType ftype = CollidingBunch ) const

virtualinherited

Gap before a particular bunch.

The function creates a smart BunchCrossing out of the BCID provided, then it goes looking for the previous bunch crossing of the specified type.

Finally it just calculates the distance between the two bunch crossings in the requested units. It can return the size of the gap either in nanoseconds or in BCIDs (25 ns steps).

Parameters

bcid	The bcid that should be investigated
dtype	The type of the requested return value
ftype	The type of the previous bunch to consider

Returns

The gap before the specified bcid

Implements Trig::IBunchCrossingTool.

Definition at line 454 of file BunchCrossingToolBase.cxx.

                                                                          {
 
      // Construct this "smart" BCID:
      const BunchCrossing bunch( bcid );
 
      // Search for the first previous bunch that fulfills the requirement:
      BunchCrossing prev_bunch( bunch );
      --prev_bunch;
      int loop_counter = 0;
      switch( ftype ) {
 
      case CollidingBunch:
         // There should always be filled bunches in the configuration, but
         // let's make sure that we don't get into an endless loop:
         while( ( ! isFilled( prev_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            --prev_bunch;
            ++loop_counter;
         }
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            ATH_MSG_ERROR( "Failed to calculate gap before BCID "
                           << bcid << " to a filled bunch! This shouldn't have "
                           << "happened!" );
            return -1;
         }
         break;
      case UnpairedBunch:
         // There are no unpaired bunches in every configuration, so make sure
         // we don't get into an endless loop:
         while( ( ! isUnpaired( prev_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            --prev_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches in the configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case UnpairedBeam1:
         // There are no unpaired bunches from beam 1 in every configuration, so
         // make sure we don't get into an endless loop:
         while( ( ! ( isUnpaired( prev_bunch ) && isBeam1( prev_bunch ) ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            --prev_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches from beam 1 in the
         // configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case UnpairedBeam2:
         // There are no unpaired bunches from beam 2 in every configuration, so
         // make sure we don't get into an endless loop:
         while( ( ! ( isUnpaired( prev_bunch ) && isBeam2( prev_bunch ) ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            --prev_bunch;
            ++loop_counter;
         }
         // Return "-1" if there are no unpaired bunches from beam 2 in the
         // configuration:
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            return -1;
         }
         break;
      case EmptyBunch:
         // There should always be empty bunches in the configuration, but let's
         // make sure that we don't get into an endless loop:
         while( ( isFilled( prev_bunch ) || isUnpaired( prev_bunch ) ) &&
                ( loop_counter < BunchCrossing::MAX_BCID ) ) {
            --prev_bunch;
            ++loop_counter;
         }
         if( loop_counter == BunchCrossing::MAX_BCID ) {
            ATH_MSG_ERROR( "Failed to calculate gap before BCID "
                           << bcid << " to an empty bunch! This shouldn't have "
                           << "happened!" );
            return -1;
         }
         break;
      default:
         ATH_MSG_ERROR( "Unknown bunch fill type specified: "
                        << ftype );
         return -1;
      }
 
      // Now return the results:
      switch( dtype ) {
 
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING * bunch.gapFrom( prev_bunch );
         break;
      case BunchCrossings:
         return bunch.gapFrom( prev_bunch );
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapBeforeBunch" );
         return -1;
      }
 
      // This should actually never be reached:
      return -1;
   }

gapBeforeTrain()

int Trig::BunchCrossingToolBase::gapBeforeTrain ( bcid_type bcid, BunchDistanceType type = NanoSec ) const

virtualinherited

Gap before the train this BCID is in.

The function first finds the train that the specified BCID is in.

Then it calculates the size of the gap before this train. It can return the size of the gap either in nanoseconds or in BCIDs (25 ns steps).

Parameters

bcid	The bcid whose train should be investigated
type	The type of the requested return value

Returns

The gap before the train of the specified bcid

Implements Trig::IBunchCrossingTool.

Definition at line 376 of file BunchCrossingToolBase.cxx.

                                                                                           {
      const auto train = std::ranges::find_if(m_bunchTrains,
          [bcid](const BunchTrain& bunchTrain) {
          return bunchTrain.contains(bcid);
      });
      // If we didn't find this BCID in a train, let's return right away:
      if( train == m_bunchTrains.end() ) {
         return -1;
      }
      // Search for the first filled bunch before the front of this train:
      BunchCrossing trainFront = *train->train_front();
      BunchCrossing prevFilled = trainFront;
      while (!isFilled(--prevFilled));
      auto dist = train->train_front()->distance( prevFilled );
      // Now return the results:
      switch( type ) {
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING * dist;
         break;
      case BunchCrossings:
         return dist;
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapBeforeTrain" );
         return -1;
      }
   }

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

handle()

void asg::AsgMetadataTool::handle ( const Incident & inc )

protectedvirtualinherited

Function receiving incidents from IncidentSvc/Event.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 135 of file AsgMetadataTool.cxx.

                                                     {
 
      // Tell the user what's happening:
      ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
 
      // Call the appropriate member function:
      if( inc.type() == IncidentType::BeginInputFile ) {
        m_beginInputFileCalled = true;
        if( beginInputFile().isFailure() ) {
          ATH_MSG_FATAL( "Failed to call beginInputFile()" );
          throw std::runtime_error( "Couldn't call beginInputFile()" );
         }
      } else if( inc.type() == IncidentType::EndInputFile ) {
        if( endInputFile().isFailure() ) {
          ATH_MSG_FATAL( "Failed to call endInputFile()" );
          throw std::runtime_error( "Couldn't call endInputFile()" );
         }
      } else if( inc.type() == IncidentType::BeginEvent ) {
         // If the tool didn't catch the begin input file incident for the
         // first input file of the job, then call the appropriate function
         // now.
         if( ! m_beginInputFileCalled ) {
            m_beginInputFileCalled = true;
            if( beginInputFile().isFailure() ) {
               ATH_MSG_FATAL( "Failed to call beginInputFile()" );
               throw std::runtime_error( "Couldn't call beginInputFile()" );
            }
         }
         if( beginEvent().isFailure() ) {
            ATH_MSG_FATAL( "Failed to call beginEvent()" );
            throw std::runtime_error( "Couldn't call beginEvent()" );
         }
 
     #ifdef XAOD_STANDALONE
      } else if( inc.type() == IncidentType::MetaDataStop ) {
         if( metaDataStop().isFailure() ) {
            ATH_MSG_FATAL( "Failed to call metaDataStop()" );
            throw std::runtime_error( "Couldn't call metaDataStop()" );
         }
         
     #endif // XAOD_STANDALONE
      } else {
         ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
      }
 
      return;
   }

initialize()

StatusCode Trig::TrigConfBunchCrossingTool::initialize ( void )

privatevirtual

Create a proper constructor for Athena.

Regular AlgTool initialization function

Reimplemented from asg::AsgTool.

Definition at line 50 of file TrigConfBunchCrossingTool.cxx.

                                                    {
 
      // Reset he bunch group ID, so at the next update we definitely
      // load a new configuration:
      m_bgId = -1;
 
      // Report about the initialization:
      ATH_MSG_INFO( "Initializing TrigConfBunchCrossingTool" );
      ATH_MSG_INFO( "  Maximal bunch spacing: " << m_maxBunchSpacing << " ns" );
      ATH_MSG_INFO( "  Length of train front: " << m_frontLength << " ns" );
      ATH_MSG_INFO( "  Length of train tail : " << m_tailLength << " ns" );
#ifndef XAOD_STANDALONE
      ATH_MSG_DEBUG( "  LVL1 config service  : " << m_configSvc );
#endif // XAOD_STANDALONE
      ATH_MSG_DEBUG( "  Trig config tool     : " << m_configTool );
 
      // Retrieve the trigger configuration service/tool:
#ifndef XAOD_STANDALONE
      if (!m_configTool.empty()) {
        ATH_MSG_DEBUG( "  xAODConfigTool is set - will read from xAOD metadata" );
        ATH_CHECK( m_configTool.retrieve() );
      } else {
        ATH_MSG_DEBUG( "  xAODConfigTool is not set - will read from xAODConfigSvc" );
        ATH_CHECK( m_configSvc.retrieve() );
      }
#else
      ATH_CHECK( m_configTool.retrieve() );
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

inputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::inputMetaStore ( ) const

inherited

Accessor for the input metadata store.

Definition at line 93 of file AsgMetadataTool.cxx.

                                                                       {
 
#ifdef XAOD_STANDALONE
      return &m_inputMetaStore;
#else // XAOD_STANDALONE
      return m_inputMetaStore;
#endif // XAOD_STANDALONE
   }

isBeam1()

bool Trig::BunchCrossingToolBase::isBeam1 ( bcid_type bcid ) const

virtualinherited

Function deciding if there was a bunch from "beam 1" in this bunch crossing.

Implements Trig::IBunchCrossingTool.

Definition at line 68 of file BunchCrossingToolBase.cxx.

                                                             {
 
      // Check if this is a filled bunch:
      std::set< BunchCrossing >::const_iterator itr_fill =
         m_filledBunches.find( bcid );
      if( itr_fill != m_filledBunches.end() ) {
         return true;
      }
 
      // Check if this is an unpaired bunch with the bunch in beam 1:
      std::set< BunchCrossing >::const_iterator itr_unp =
         m_unpairedBunches.find( bcid );
      if( ( itr_unp != m_unpairedBunches.end() ) &&
          ( itr_unp->intensityBeam1() > 0.001 ) ) {
         return true;
      } else {
         return false;
      }
   }

isBeam2()

bool Trig::BunchCrossingToolBase::isBeam2 ( bcid_type bcid ) const

virtualinherited

Function deciding if there was a bunch from "beam 2" in this bunch crossing.

Implements Trig::IBunchCrossingTool.

Definition at line 88 of file BunchCrossingToolBase.cxx.

                                                             {
 
      // Check if this is a filled bunch:
      std::set< BunchCrossing >::const_iterator itr_fill =
         m_filledBunches.find( bcid );
      if( itr_fill != m_filledBunches.end() ) {
         return true;
      }
 
      // Check if this is an unpaired bunch with the bunch in beam 1:
      std::set< BunchCrossing >::const_iterator itr_unp =
         m_unpairedBunches.find( bcid );
      if( ( itr_unp != m_unpairedBunches.end() ) &&
          ( itr_unp->intensityBeam2() > 0.001 ) ) {
         return true;
      } else {
         return false;
      }
   }

isFilled()

bool Trig::BunchCrossingToolBase::isFilled ( bcid_type bcid ) const

virtualinherited

The simplest query: Is the bunch crossing filled or not?

Implements Trig::IBunchCrossingTool.

Definition at line 34 of file BunchCrossingToolBase.cxx.

                                                              {
 
      // Check if this is a filled bunch crossing:
      if( m_filledBunches.find( bcid ) != m_filledBunches.end() ) {
         return true;
      } else {
         return false;
      }
   }

isInTrain()

bool Trig::BunchCrossingToolBase::isInTrain ( bcid_type bcid ) const

virtualinherited

Function deciding if a given bunch crossing is in a filled train.

Implements Trig::IBunchCrossingTool.

Definition at line 44 of file BunchCrossingToolBase.cxx.

                                                               {
 
      // Look for this BCID in the list of bunch trains:
      std::set< BunchTrain >::const_iterator itr = m_bunchTrains.begin();
      std::set< BunchTrain >::const_iterator end = m_bunchTrains.end();
      for( ; itr != end; ++itr ) {
         if( itr->find( bcid ) != itr->end() ) {
            return true;
         }
      }
 
      return false;
   }

isUnpaired()

bool Trig::BunchCrossingToolBase::isUnpaired ( bcid_type bcid ) const

virtualinherited

Function deciding if a given bunch crossing has an unpaired bunch.

Implements Trig::IBunchCrossingTool.

Definition at line 58 of file BunchCrossingToolBase.cxx.

                                                                {
 
      // Check if this is an unpaired bunch crossing:
      if( m_unpairedBunches.find( bcid ) != m_unpairedBunches.end() ) {
         return true;
      } else {
         return false;
      }
   }

loadBunchTrains()

StatusCode Trig::BunchCrossingToolBase::loadBunchTrains ( const std::vector< int > & bunches, const std::vector< float > & bunch_int1 = std::vector< float >(), const std::vector< float > & bunch_int2 = std::vector< float >() )

protectedinherited

Interpret the configuration for bunch trains.

This function takes care of identifying the bunch trains in the configuration.

The algorithm is quite simple. It starts off with all the filled bunches that have not been identified as single bunches by the loadSingleBunches(...) function. It takes the first available bunch crossing, then loops over the rest of them. When it finds a BC that's "close enough" to the current bunch train, then the bunch train is extended. From there on the algorithm continues with this extended bunch train. When the loop reaches the end of the available bunches, the created bunch train is added to the cache, and the algorithms starts again with the first still available bunch crossing.

The bunch intensity parameter is optional. If it's not specified, the code will assign an intensity of "1.0" to all the bunch crossings.

Parameters

bunches	The filled bunch crossings
bunch_int	The "intensities" of the paired bunches

Returns

StatusCode::SUCCESS if the interpretation was successful, StatusCode::FAILURE otherwise

Definition at line 953 of file BunchCrossingToolBase.cxx.

                                                           {
 
      // Do a small sanity check:
      if( ( ( bunches.size() != bunch_int1.size() ) && bunch_int1.size() ) ||
          ( ( bunches.size() != bunch_int2.size() ) && bunch_int2.size() ) ) {
         ATH_MSG_ERROR( "Received vectors of different sizes for the bunch "
                        "IDs and bunch intensities\n"
                        "Function can not work like this..." );
         return StatusCode::FAILURE;
      }
      if( ! bunch_int1.size() ) {
         ATH_MSG_DEBUG( "Not using bunch intensity for the calculation" );
      }
      if( ( ! bunch_int2.size() ) && bunch_int1.size() ) {
         ATH_MSG_DEBUG( "Using 'bunch crossing intensity' for the "
                        "calculation" );
      }
 
      //
      // Calculate the allowed maximum BCID separation between single bunches:
      //
      const int maxBCSpacing = bunchSpacing( bunches );
 
      // Reset the cache:
      m_bunchTrains.clear();
 
      //
      // Create a cache of the bunches which have not been identified as a
      // single bunch:
      //
      std::set< BunchCrossing > cache;
      std::vector< int >::const_iterator b_itr = bunches.begin();
      std::vector< int >::const_iterator b_end = bunches.end();
      std::vector< float >::const_iterator i1_itr = bunch_int1.begin();
      std::vector< float >::const_iterator i2_itr = bunch_int2.begin();
      for( ; b_itr != b_end; ++b_itr ) {
         if( std::find( m_singleBunches.begin(), m_singleBunches.end(),
                        BunchCrossing( *b_itr ) ) == m_singleBunches.end() ) {
            cache.insert( BunchCrossing( *b_itr,
                                         ( float )( bunch_int1.size() ? *i1_itr :
                                                    1.0 ),
                                         ( float )( bunch_int2.size() ? *i2_itr :
                                                    0.0 ) ) );
         }
         if( bunch_int1.size() ) ++i1_itr;
         if( bunch_int2.size() ) ++i2_itr;
      }
 
      ATH_MSG_VERBOSE( "Bunches considered for trains: " << cache );
 
      //
      // Continue the loop until we have unassigned bunches:
      //
      while( cache.size() ) {
 
         // Create a new bunch train object:
         BunchTrain bt;
         bt.insert( *cache.begin() );
 
         // Try finding attachable bunches until no other attachable bunch can
         // be found:
         size_t prev_size = 0;
         while( prev_size != cache.size() ) {
 
            // Let's remember the size of the cache:
            prev_size = cache.size();
 
            // Find all the bunches that should be a part of this train:
            std::set< BunchCrossing >::const_iterator c_itr = cache.begin();
            std::set< BunchCrossing >::const_iterator c_end = cache.end();
            for( ; c_itr != c_end; ++c_itr ) {
               if( bt.distance( *c_itr ) <= maxBCSpacing ) {
                  ATH_MSG_VERBOSE( "Adding BunchCrossing " << *c_itr
                                   << " to Bunch Train " << bt );
                  bt.insert( *c_itr );
               }
            }
 
            // Now remove the selected bunches from the cache:
            BunchTrain::const_iterator itr = bt.begin();
            BunchTrain::const_iterator end = bt.end();
            for( ; itr != end; ++itr ) {
               cache.erase( *itr );
            }
         }
 
         // Finally, remember this train:
         if( ! bt.validate() ) {
            ATH_MSG_ERROR( "Found a strange bunch train: " << bt );
            ATH_MSG_ERROR( "Keeping in it the list of trains!" );
         }
         m_bunchTrains.insert( bt );
      }
 
      //
      // Check if the spacing in the bunch trains is the same. (It should be for
      // all real configurations.)
      //
      std::set< BunchTrain >::const_iterator train_itr = m_bunchTrains.begin();
      std::set< BunchTrain >::const_iterator train_end = m_bunchTrains.end();
      int spacing = -1;
      for( ; train_itr != train_end; ++train_itr ) {
         if( spacing < 0 ) {
            spacing = train_itr->spacing();
            continue;
         }
         if( train_itr->spacing() != spacing ) {
            ATH_MSG_WARNING( "The spacing seems to be different between the "
                             "trains" );
            ATH_MSG_WARNING( "This should probably not happen" );
         }
      }
 
      ATH_MSG_DEBUG( "Bunch trains found: " << m_bunchTrains );
 
      return StatusCode::SUCCESS;
   }

loadConfig()

StatusCode Trig::TrigConfBunchCrossingTool::loadConfig ( )

private

Make sure that the latest/correct configuration is loaded.

This function makes sure that the latest configuration from the TriggerDB is loaded.

It has to be called using some mechanism, which is the incident mechanism at the moment.

The function checks if the currently loaded configuration is the same as the most recent configuration available from the trigger configuration service. If it's not, then it loads the current configuration from the trigger config service.

Returns

StatusCode::SUCCESS if the operation wa successful, or StatusCode::FAILURE if it wasn't.

Definition at line 175 of file TrigConfBunchCrossingTool.cxx.

                                                    {
 
      // Decide where to take the configuration from:
      TrigConf::IILVL1ConfigSvc* configSvc = 0;
#ifndef XAOD_STANDALONE
      if (m_configTool.isSet()) {
        configSvc = m_configTool.operator->();
      } else {
        configSvc = m_configSvc.operator->();
      }
#else
      configSvc = m_configTool.operator->();
#endif // not XAOD_STANDALONE
 
      // Check if the needed info is even there:
      if( ! configSvc->bunchGroupSet() ) {
         ATH_MSG_FATAL( "Trigger configuration service doesn't provide "
                        "BunchGroupSet information" );
         return StatusCode::FAILURE;
      }
 
      // Check if we already have the correct configuration:
      if( configSvc->bunchGroupSet()->id() == m_bgId ) {
         return StatusCode::SUCCESS;
      }
 
      // Report to the user what we're doing:
      ATH_MSG_INFO( "Updating tool configuration to BGKey #"
                    << configSvc->bunchGroupSet()->id() );
 
      // Print the configuration for debugging purposes, and remember which one
      // we're processing:
      m_bgId = configSvc->bunchGroupSet()->id();
      printBunchGroups( configSvc );
 
      //
      // Select the collision bunch group:
      //
      const std::vector< TrigConf::BunchGroup >& bgs =
         configSvc->bunchGroupSet()->bunchGroups();
      std::vector< TrigConf::BunchGroup >::const_iterator filled_bg =
         bgs.begin();
      ++filled_bg;
      ATH_MSG_INFO( "Taking the second bunch group as the colliding bunch "
                    "group" );
 
      //
      // Now interpret the information:
      //
      ATH_CHECK( loadSingleBunches( filled_bg->bunches() ) );
      ATH_CHECK( loadBunchTrains( filled_bg->bunches() ) );
 
      //
      // Select the unpaired bunches. The overlaps are taken care of by the
      // base tool.
      //
      std::vector< int > unpaired;
      // These are the "unpaired isolated" bunches:
      if( bgs.size() > 4 ) {
         unpaired.insert( unpaired.end(), bgs[ 4 ].bunches().begin(),
                          bgs[ 4 ].bunches().end() );
      }
      // These are the "unpaired non-isolated" bunches:
      if( bgs.size() > 5 ) {
         unpaired.insert( unpaired.end(), bgs[ 5 ].bunches().begin(),
                          bgs[ 5 ].bunches().end() );
      }
 
      //
      // Now interpret the information:
      //
      ATH_CHECK( loadUnpairedBunches( unpaired, unpaired ) );
 
      // Print the configuration to give some feedback to the user:
      printConfig();
 
#ifndef XAOD_STANDALONE
      // Let everybody know that the configuration of the tool has changed:
      ServiceHandle< IIncidentSvc > incidentSvc( "IncidentSvc", name() );
      ATH_CHECK( incidentSvc.retrieve() );
      incidentSvc->fireIncident( Incident( "BunchConfiguration update",
                                           BUNCH_CONFIG_INCIDENT_NAME ) );
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

loadSingleBunches()

StatusCode Trig::BunchCrossingToolBase::loadSingleBunches ( const std::vector< int > & bunches, const std::vector< float > & bunch_int1 = std::vector< float >(), const std::vector< float > & bunch_int2 = std::vector< float >() )

protectedinherited

Interpret the configuration for single bunches.

This function takes care of selecting the single bunches from the paired bunches.

These will then not be taken into account in the train finding algorithm.

The bunch intensity parameter is optional. If it's not specified, the code will assign an intensity of "1.0" to all the bunch crossings.

Parameters

bunches	The paired bunches
bunch_int	The "intensities" of the paired bunches

Returns

StatusCode::SUCCESS if the interpretation was successful, StatusCode::FAILURE otherwise

Definition at line 837 of file BunchCrossingToolBase.cxx.

                                                             {
 
      // Do a small sanity check:
      if( ( ( bunches.size() != bunch_int1.size() ) && bunch_int1.size() ) ||
          ( ( bunches.size() != bunch_int2.size() ) && bunch_int2.size() ) ) {
         ATH_MSG_ERROR( "Received vectors of different sizes for the bunch "
                        "IDs and bunch intensities\n"
                        "Function can not work like this..." );
         return StatusCode::FAILURE;
      }
      if( ! bunch_int1.size() ) {
         ATH_MSG_DEBUG( "Not using bunch intensity for the calculation" );
      }
      if( ( ! bunch_int2.size() ) && bunch_int1.size() ) {
         ATH_MSG_DEBUG( "Using 'bunch crossing intensity' for the "
                        "calculation" );
      }
 
      //
      // Calculate the allowed maximum BCID separation between single bunches:
      //
      const int maxBCSpacing = bunchSpacing( bunches );
 
      // Reset the cache:
      m_filledBunches.clear();
      m_singleBunches.clear();
 
      //
      // Loop over the paired bunch crossings:
      //
      std::vector< int >::const_iterator b_itr = bunches.begin();
      std::vector< int >::const_iterator b_end = bunches.end();
      std::vector< float >::const_iterator i1_itr = bunch_int1.begin();
      std::vector< float >::const_iterator i2_itr = bunch_int2.begin();
      for( ; b_itr != b_end; ++b_itr ) {
 
         // Evaluate the intensity of this paired bunch:
         const float intensity1 = bunch_int1.size() ? *i1_itr : 1.0;
         const float intensity2 = bunch_int2.size() ? *i2_itr : 0.0;
 
         // It's definitely a filled bunch, so let's remember it as such:
         m_filledBunches.insert( BunchCrossing( *b_itr, intensity1,
                                                intensity2 ) );
 
         ATH_MSG_VERBOSE( "Evaluating bunch crossing: " << *b_itr );
 
         //
         // This expression counts how many of the paired bunches fulfill:
         //
         //      distance( ref_bcid,  bcid ) <= maxBCSpacing
         //
         // Since the calculation takes the reference bcid into account as well,
         // the count is always >= 1. I have to use the specialised
         // distance(...) function, because a regular
         //
         //      bcid - maxBCSpacing <= ref_bcid <= bcid + maxBCSpacing
         //
         // expression wouldn't give the correct answer at the "turnover" of the
         // bcid numbering. (When evaluating bcid 1 and
         // BunchCrossing::MAX_BCID.)
         //
         const int neighbours =
            std::count_if( bunches.begin(), bunches.end(),
                           [ maxBCSpacing, &b_itr ]( int bunch ) {
                              return ( Trig::distance( bunch, *b_itr ) <=
                                       maxBCSpacing );
                           } );
 
         //
         // Now decide if we want to consider this bunch crossing as a single
         // bunch or not:
         //
         ATH_MSG_VERBOSE( "  Bunch neighbours: " << neighbours );
         if( neighbours == 1 ) {
            ATH_MSG_VERBOSE( "  Bunch crossing " << *b_itr
                             << " seems to be a single bunch" );
            m_singleBunches.insert( BunchCrossing( *b_itr, intensity1,
                                                   intensity2 ) );
         }
 
         // Only step through the intensity vector(s) if it has some elements:
         if( bunch_int1.size() ) ++i1_itr;
         if( bunch_int2.size() ) ++i2_itr;
      }
 
      //
      // Finally some debugging message for the end:
      //
      ATH_MSG_DEBUG( "Single bunches found: " << m_singleBunches );
 
      return StatusCode::SUCCESS;
   }

loadUnpairedBunches()

StatusCode Trig::BunchCrossingToolBase::loadUnpairedBunches ( const std::vector< int > & beam1, const std::vector< int > & beam2, const std::vector< float > & bunch_int1 = std::vector< float >(), const std::vector< float > & bunch_int2 = std::vector< float >() )

protectedinherited

Interpret the configuration for unpaired bunches.

This function just caches the unpaired bunches internally.

It doesn't have to do anything as fancy as the other two load functions, it just takes the BCIDs as they are.

Parameters

bunches	The unpaired bunch crossings
bunch_int	The "intensities" of the unpaired bunches

Returns

StatusCode::SUCCESS if the caching was successful, StatusCode::FAILURE otherwise

Definition at line 1084 of file BunchCrossingToolBase.cxx.

                                                               {
 
      // Do a small sanity check:
      if( ( ( beam1.size() != bunch_int1.size() ) && bunch_int1.size() ) ||
          ( ( beam2.size() != bunch_int2.size() ) && bunch_int2.size() ) ) {
         ATH_MSG_ERROR( "Received vectors of different sizes for the bunch "
                        "IDs and bunch intensities\n"
                        "Function can not work like this..." );
         return StatusCode::FAILURE;
      }
      if( ( ! bunch_int1.size() ) && ( ! bunch_int2.size() ) ) {
         ATH_MSG_DEBUG( "Not using bunch intensity for the calculation" );
      }
 
      // Reset the cache:
      m_unpairedBunches.clear();
 
      //
      // Add the unpaired bunches from beam 1:
      //
      std::vector< int >::const_iterator b_itr = beam1.begin();
      std::vector< int >::const_iterator b_end = beam1.end();
      std::vector< float >::const_iterator i_itr = bunch_int1.begin();
      for( ; b_itr != b_end; ++b_itr ) {
 
         // Evaluate the intensity of this unpaired bunch:
         const float intensity = bunch_int1.size() ? *i_itr : 1.0;
 
         // Nothing fancy to do, just put it in the cache:
         m_unpairedBunches.insert( BunchCrossing( *b_itr, intensity, 0.0 ) );
 
         // Only step through the intensity vector if it has some elements:
         if( bunch_int1.size() ) ++i_itr;
      }
 
      //
      // Add the unpaired bunches from beam 2:
      //
      b_itr = beam2.begin();
      b_end = beam2.end();
      i_itr = bunch_int2.begin();
      for( ; b_itr != b_end; ++b_itr ) {
 
         // Evaluate the intensity of this unpaired bunch:
         const float intensity = bunch_int2.size() ? *i_itr : 1.0;
 
         // Check if this BCID is already known as an unpaired BCID:
         std::set< BunchCrossing >::iterator itr =
            m_unpairedBunches.find( *b_itr );
         if( itr != m_unpairedBunches.end() ) {
            // Modify the BCID not to correspond to a particular beam. Most
            // implementations don't treat beam 1 and beam 2 separately.
            BunchCrossing bc( *itr );
            bc.setIntensityBeam2( intensity );
            m_unpairedBunches.erase( itr );
            m_unpairedBunches.insert( bc );
         } else {
            // Nothing fancy to do, just put it in the cache:
            m_unpairedBunches.insert( BunchCrossing( *b_itr, 0.0, intensity ) );
         }
 
         // Only step through the intensity vector if it has some elements:
         if( bunch_int2.size() ) ++i_itr;
      }
 
      //
      // Finally some debugging message for the end:
      //
      ATH_MSG_DEBUG( "Unpaired bunches found: " << m_unpairedBunches );
 
      return StatusCode::SUCCESS;
   }

metaDataStop()

StatusCode asg::AsgMetadataTool::metaDataStop ( )

protectedvirtualinherited

Function called when the tool should write out its metadata.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in BookkeeperDumperTool, BookkeeperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 209 of file AsgMetadataTool.cxx.

                                            {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

numberOfBunchTrains()

unsigned int Trig::BunchCrossingToolBase::numberOfBunchTrains ( ) const

virtualinherited

Get the number of the bunch trains in the current configuration.

Implements Trig::IBunchCrossingTool.

Definition at line 788 of file BunchCrossingToolBase.cxx.

                                                                 {
 
      return m_bunchTrains.size();
   }

numberOfFilledBunches()

unsigned int Trig::BunchCrossingToolBase::numberOfFilledBunches ( ) const

virtualinherited

Get the number of filled bunches in the current configuration.

Implements Trig::IBunchCrossingTool.

Definition at line 778 of file BunchCrossingToolBase.cxx.

                                                                   {
 
      return m_filledBunches.size();
   }

numberOfUnpairedBunches()

unsigned int Trig::BunchCrossingToolBase::numberOfUnpairedBunches ( ) const

virtualinherited

Get the number of unpaired bunches in the current configuration.

Implements Trig::IBunchCrossingTool.

Definition at line 783 of file BunchCrossingToolBase.cxx.

                                                                     {
 
      return m_unpairedBunches.size();
   }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

outputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::outputMetaStore ( ) const

inherited

Accessor for the output metadata store.

Definition at line 102 of file AsgMetadataTool.cxx.

                                                                        {
 
#ifdef XAOD_STANDALONE
      return &m_outputMetaStore;
#else // XAOD_STANDALONE
      return m_outputMetaStore;
#endif // XAOD_STANDALONE
   }

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

printBunchGroups()

void Trig::TrigConfBunchCrossingTool::printBunchGroups ( const TrigConf::IILVL1ConfigSvc * svc ) const

private

Print the "raw" configuration for debugging.

This function is only here for debugging.

It prints practically the full configuration information that the tool has to work with.

Definition at line 267 of file TrigConfBunchCrossingTool.cxx.

                                                                {
 
      // Skip the rest if nothing will be printed anyway:
      if( ! msgLvl( MSG::VERBOSE ) ) return;
 
      // Print the information:
      ATH_MSG_VERBOSE( "Printing BunchGroup configuration:" );
      for( const auto& bg : svc->bunchGroupSet()->bunchGroups() ) {
         ATH_MSG_VERBOSE( "  BG \"" << bg.name() << "\": " << bg.bunches() );
      }
 
      // Return gracefully:
      return;
   }

printConfig()

void Trig::BunchCrossingToolBase::printConfig ( ) const

protectedinherited

Function printing the configuration of the tool.

This function is used to print the overall configuration in a format very similar to how atlas-runqery.cern.ch started showing this information recently.

Definition at line 1166 of file BunchCrossingToolBase.cxx.

                                                 {
 
      ATH_MSG_INFO( "No. of coll. bunches   : " << m_filledBunches.size() );
      ATH_MSG_INFO( "No. of unpaired bunches: " << m_unpairedBunches.size() );
      ATH_MSG_INFO( "No. of bunch trains    : " << m_bunchTrains.size() );
      if( m_bunchTrains.size() ) {
         ATH_MSG_INFO( "Bunch spacing in trains: "
                       << m_bunchTrains.begin()->spacing()
                       << " ns" );
      }
 
      return;
   }

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setUseIncidents()

void asg::AsgMetadataTool::setUseIncidents ( const bool flag )

inlineprotectedinherited

Definition at line 132 of file AsgMetadataTool.h.

   {
      m_useIncidents = flag;
   }

sysInitialize()

StatusCode asg::AsgMetadataTool::sysInitialize ( )

virtualinherited

Function initialising the tool in the correct way in Athena.

This function is used to set up the callbacks from IncidentSvc in Athena at the right time during initialisation, without the user having to do anything special in his/her code.

Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.

Definition at line 115 of file AsgMetadataTool.cxx.

                                             {
 
#ifndef XAOD_STANDALONE
      if (m_useIncidents) {
         // Connect to the IncidentSvc:
         ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
         ATH_CHECK( incSvc.retrieve() );
 
         // Set up the right callbacks: don't rethrow exceptions, any failure and we should end
         incSvc->addListener( this, IncidentType::BeginEvent, 0, false );
      }
      // Let the base class do its thing:
      ATH_CHECK( AlgTool::sysInitialize() );
 
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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

BUNCH_CONFIG_INCIDENT_NAME

const std::string Trig::BunchCrossingConfProviderBase::BUNCH_CONFIG_INCIDENT_NAME = "BunchConfig"

staticprotectedinherited

Type name for the incident that such tools should emit.

Definition at line 52 of file BunchCrossingConfProviderBase.h.

m_beginInputFileCalled

bool asg::AsgMetadataTool::m_beginInputFileCalled

privateinherited

Flag helping to discover when the tool misses the opening of the first input file.

Definition at line 126 of file AsgMetadataTool.h.

m_bgId

unsigned int Trig::TrigConfBunchCrossingTool::m_bgId {0}

private

DB ID of the BunchGroups settings which was loaded last.

Definition at line 82 of file TrigConfBunchCrossingTool.h.

{0};

m_bunchTrains

std::set< Trig::BunchTrain > Trig::BunchCrossingToolBase::m_bunchTrains

protectedinherited

Internal list of bunch trains.

Definition at line 156 of file BunchCrossingToolBase.h.

m_configSvc

ServiceHandle<TrigConf::ILVL1ConfigSvc> Trig::TrigConfBunchCrossingTool::m_configSvc

private

Initial value:

{
        this, "ConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc"}

The config service handle.

Definition at line 86 of file TrigConfBunchCrossingTool.h.

                                                       {
        this, "ConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc"};

m_configTool

ToolHandle<TrigConf::ITrigConfigTool> Trig::TrigConfBunchCrossingTool::m_configTool

private

Initial value:

{
        this, "ConfigTool", "TrigConf::xAODConfigTool"}

The config tool handle.

Definition at line 91 of file TrigConfBunchCrossingTool.h.

                                                      {
        this, "ConfigTool", "TrigConf::xAODConfigTool"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_filledBunches

std::set< Trig::BunchCrossing > Trig::BunchCrossingToolBase::m_filledBunches

protectedinherited

List of colliding bunches.

Definition at line 150 of file BunchCrossingToolBase.h.

m_frontLength

int Trig::BunchCrossingToolBase::m_frontLength

protectedinherited

Length of the "front" of a bunch train.

Definition at line 166 of file BunchCrossingToolBase.h.

m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore

privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

m_maxBunchSpacing

int Trig::BunchCrossingToolBase::m_maxBunchSpacing

protectedinherited

The maximum bunch spacing that the tool should consider.

Definition at line 164 of file BunchCrossingToolBase.h.

m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore

privateinherited

Object accessing the output metadata store.

Definition at line 121 of file AsgMetadataTool.h.

m_singleBunches

std::set< Trig::BunchCrossing > Trig::BunchCrossingToolBase::m_singleBunches

protectedinherited

Internal list of single bunches.

Definition at line 152 of file BunchCrossingToolBase.h.

m_tailLength

int Trig::BunchCrossingToolBase::m_tailLength

protectedinherited

Length of the "tail" of a bunch train.

Definition at line 168 of file BunchCrossingToolBase.h.

m_unpairedBunches

std::set< Trig::BunchCrossing > Trig::BunchCrossingToolBase::m_unpairedBunches

protectedinherited

Internal list of unpaired bunches.

Definition at line 154 of file BunchCrossingToolBase.h.

m_useIncidents

bool asg::AsgMetadataTool::m_useIncidents

privateinherited

Definition at line 128 of file AsgMetadataTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigConfBunchCrossingTool.h
• TrigConfBunchCrossingTool.cxx