Trig::StaticBunchCrossingTool Class Reference

Stand-alone bunch group tool knowing some static configurations. More...

#include <StaticBunchCrossingTool.h>

Inheritance diagram for Trig::StaticBunchCrossingTool:

Collaboration diagram for Trig::StaticBunchCrossingTool:

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.
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
	StaticBunchCrossingTool (const std::string &name="StaticBunchCrossingTool")
	Create a proper constructor for Athena.
virtual StatusCode	initialize ()
	Function initialising the tool.
StatusCode	loadConfig (int bgkey)
	Load a hard-coded bunch group key.
StatusCode	loadConfig (const std::vector< int > &filledBunches, const std::vector< float > &filledIntensities=std::vector< float >(), const std::vector< int > &unpairedBunches=std::vector< int >(), const std::vector< float > &unpairedIntensities=std::vector< float >())
	Load a configuration specified by the user.
StatusCode	loadConfig (const std::vector< float > &bunches)
	Load the configuration specified by the user.
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
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
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/TEvent.
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	beginEvent ()
	Function called when a new events is loaded.
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
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
int	m_bgkey
	Default key to be loaded.
std::map< int, std::vector< int > >	m_knownBGKeys
	All the hard-coded configs.
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

Stand-alone bunch group tool knowing some static configurations.

   This tool can be used out of the box to get information about some
   of the bunch layouts which were used to take data. It takes its
   knowledge from the "StaticConfigs.h" file.

   It can be used in a standalone analysis code to analyse ntuples
   for instance.

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

Revision

749252

Date

2016-05-24 11:30:51 +0200 (Tue, 24 May 2016)

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

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

Constructor & Destructor Documentation

StaticBunchCrossingTool()

Trig::StaticBunchCrossingTool::StaticBunchCrossingTool

(

const std::string &

name = "StaticBunchCrossingTool"

)

Create a proper constructor for Athena.

The constructor reads all the configurations out of "StaticConfigs.h" and sets up the tool using those.

Default constructor

Definition at line 17 of file StaticBunchCrossingTool.cxx.

      : BunchCrossingToolBase( name ),
        m_knownBGKeys() {
 
      // Declare the property of the tool:
      declareProperty( "BGKey", m_bgkey = 0 );
 
      //
      // Learn the static bunch group configurations:
      //
      for( int i = 0; i < BGK_CONF_N; ++i ) {
         for( int j = 0; j < BGK_CONF_NUM[ i ]; ++j ) {
            m_knownBGKeys[ BGK_CONF_KEY[ i ] ].push_back( BGK_CONF[ i ][ j ] );
         }
      }
   }

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 106 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 166 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 asg::AsgMetadataTool::beginEvent ( )

protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, TauAnalysisTools::TauSelectionTool, Trig::TrigConfBunchCrossingTool, Trig::TrigDecisionTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, and xAODMaker::TriggerMenuMetaDataTool.

Definition at line 201 of file AsgMetadataTool.cxx.

                                          {
 
      // 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 734 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 718 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 781 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 750 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 1225 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 827 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;
   }

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 239 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 316 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 608 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 429 of file BunchCrossingToolBase.cxx.

                                                                            {
 
      // Find 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();
      std::set< BunchTrain >::const_iterator train = m_bunchTrains.end();
      for( ; itr != end; ++itr ) {
         if( itr->find( bcid ) != itr->end() ) {
            train = itr;
            break;
         }
      }
 
      // If we didn't find this BCID in a train, let's return right away:
      if( train == end ) {
         return -1;
      }
 
      // Search for the first filled bunch before the front of this train:
      BunchCrossing train_front = *( train->train_back() );
      ++train_front;
      while( ! isFilled( train_front ) ) {
         ++train_front;
      }
 
      // Now return the results:
      switch( type ) {
 
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING *
            train_front.distance( *( train->train_back() ) );
         break;
      case BunchCrossings:
         return train_front.distance( *( train->train_back() ) );
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapAfterTrain" );
         return -1;
      }
 
      // This should actually never be reached:
      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 487 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 374 of file BunchCrossingToolBase.cxx.

                                                                             {
 
      // Find 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();
      std::set< BunchTrain >::const_iterator train = m_bunchTrains.end();
      for( ; itr != end; ++itr ) {
         if( itr->find( bcid ) != itr->end() ) {
            train = itr;
            break;
         }
      }
 
      // If we didn't find this BCID in a train, let's return right away:
      if( train == end ) {
         return -1;
      }
 
      // Search for the first filled bunch before the front of this train:
      BunchCrossing train_tail = *( train->train_front() );
      --train_tail;
      while( ! isFilled( train_tail ) ) {
         --train_tail;
      }
 
      // Now return the results:
      switch( type ) {
 
      case NanoSec:
         return BunchCrossing::BUNCH_SPACING *
            train->train_front()->distance( train_tail );
         break;
      case BunchCrossings:
         return train->train_front()->distance( train_tail );
         break;
      default:
         ATH_MSG_ERROR( "You can only use NanoSec or BunchCrossings for type "
                        "for gapBeforeTrain" );
         return -1;
      }
 
      // This should actually never be reached:
      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::TEvent 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::TEvent, 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::TEvent 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::TEvent, 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/TEvent.

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::StaticBunchCrossingTool::initialize ( void )

virtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 34 of file StaticBunchCrossingTool.cxx.

                                                  {
 
      // Let the user know what's happening:
      ATH_MSG_INFO( "Initialising tool" );
      ATH_MSG_INFO( "  Bunch group config : " << m_bgkey );
 
      // Load the configuration specified by the tool's property:
      ATH_CHECK( loadConfig( m_bgkey ) );
 
      // 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 66 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 86 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 32 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 42 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 56 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 986 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() [1/3]

StatusCode Trig::StaticBunchCrossingTool::loadConfig

(

const std::vector< float > &

bunches

)

Load the configuration specified by the user.

This helper function is here to make it possible to extract the bunch configuration from an MC file in an Athena environment, and then use that as a hardcoded configuration to initialise this tool.

In this case the argument is the intensities of the bunches. From which the code uses the same logic as MCBunchCrossingTool to find the filled bunches.

Parameters

bunches

The intensities of the BCIDs. Starting with BCID 0.

Returns

StatusCode::SUCCESS if loading the configuration was successful, StatusCode::FAILURE otherwise

Definition at line 128 of file StaticBunchCrossingTool.cxx.

                                                   {
 
      // Check that the user specified something useful:
      if( ! bunches.size() ) {
         ATH_MSG_ERROR( "Empty container received" );
         return StatusCode::FAILURE;
      }
 
      // Translate it into vectors of filled bunches and intensities:
      std::vector< int > filled_bunches;
      std::vector< float > filled_intensities;
 
      // Minimum bunch intensity to consider a bunch filled:
      static const float MIN_BUNCH_INTENSITY = 0.1;
 
      // Check if the pattern "fits into" the LHC:
      if( BunchCrossing::MAX_BCID % bunches.size() ) {
 
         ATH_MSG_INFO( "Bunch pattern doesn't \"fit into\" "
                       << BunchCrossing::MAX_BCID );
         // The loop doesn't go all the way up to MAX_BCID/2 in order not
         // to produce "weird" patterns half way. This should be pretty safe
         // to do, because the MC BCIDs will only be in the range defined by
         // the pattern from the metadata.
         for( int i = 0; i < ( BunchCrossing::MAX_BCID / 2 - 20 ); ++i ) {
            const int pos1 = i % bunches.size();
            const int pos2 = bunches.size() - 1 - ( i % bunches.size() );
            if( bunches[ pos1 ] > MIN_BUNCH_INTENSITY ) {
               filled_bunches.push_back( i );
               filled_intensities.push_back( bunches[ pos1 ] );
            }
            if( bunches[ pos2 ] > MIN_BUNCH_INTENSITY ) {
               filled_bunches.push_back( BunchCrossing::MAX_BCID - 1 - i );
               filled_intensities.push_back( bunches[ pos2 ] );
            }
         }
 
      } else {
 
         // If the sample size fits into the number of available bunches,
         // the algorithm is pretty simple:
         ATH_MSG_INFO( "Bunch pattern \"fits into\" "
                       << BunchCrossing::MAX_BCID );
         for( int i = 0; i < BunchCrossing::MAX_BCID; ++i ) {
            const int pos = i % bunches.size();
            if( bunches[ pos ] > MIN_BUNCH_INTENSITY ) {
               filled_bunches.push_back( i );
               filled_intensities.push_back( bunches[ pos ] );
            }
         }
 
      }
 
      //
      // Now let the base class interpret the information:
      //
      ATH_CHECK( loadSingleBunches( filled_bunches, filled_intensities ) );
      ATH_CHECK( loadBunchTrains( filled_bunches, filled_intensities ) );
      ATH_CHECK( loadUnpairedBunches( std::vector< int >(),
                                      std::vector< int >() ) );
 
      // Print the configuration to give some feedback to the user:
      printConfig();
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

loadConfig() [2/3]

StatusCode Trig::StaticBunchCrossingTool::loadConfig	(	const std::vector< int > &	filledBunches,
		const std::vector< float > &	filledIntensities = std::vector< float >(),
		const std::vector< int > &	unpairedBunches = std::vector< int >(),
		const std::vector< float > &	unpairedIntensities = std::vector< float >() )

Load a configuration specified by the user.

To make it possible to quickly try out new configurations, this public function configures the underlying tool from a list of bunches (and optionally bunch intensities) given by the user.

Only used for testing at the moment.

Parameters

bunches	The filled bunches which should be interpreted
intensities	The intensities of these filled bunches (optional)

Returns

StatusCode::SUCCESS if loading the configuration was successful, StatusCode::FAILURE otherwise

Definition at line 94 of file StaticBunchCrossingTool.cxx.

                                                               {
 
      //
      // Let the base class interpret the configuration:
      //
      ATH_CHECK( loadSingleBunches( filledBunches, filledIntensities ) );
      ATH_CHECK( loadBunchTrains( filledBunches, filledIntensities ) );
      ATH_CHECK( loadUnpairedBunches( unpairedBunches, unpairedBunches,
                                      unpairedIntensities,
                                      unpairedIntensities ) );
 
      // Print the configuration to give some feedback to the user:
      printConfig();
 
      return StatusCode::SUCCESS;
   }

loadConfig() [3/3]

StatusCode Trig::StaticBunchCrossingTool::loadConfig

(

int

bgkey

)

Load a hard-coded bunch group key.

This function tries to load one of the pre-defined configurations.

The code knows about all the bunch-group settings up to BGKey=105 at the moment.

Parameters

bgkey

Bunch group key of the requested configuration

Returns

StatusCode::SUCCESS if loading the configuration was successful, StatusCode::FAILURE otherwise

Definition at line 56 of file StaticBunchCrossingTool.cxx.

                                                             {
 
      //
      // Check if we have this configuration:
      //
      std::map< int, std::vector< int > >::const_iterator bgset;
      if( ( bgset = m_knownBGKeys.find( bgkey ) ) == m_knownBGKeys.end() ) {
         ATH_MSG_ERROR( "Couldn't find configuration for bunch group key: "
                        << bgkey );
         return StatusCode::FAILURE;
      }
 
      //
      // Now let the base class interpret the configuration:
      //
      ATH_CHECK( loadSingleBunches( bgset->second ) );
      ATH_CHECK( loadBunchTrains( bgset->second ) );
      ATH_CHECK( loadUnpairedBunches( std::vector< int >(),
                                      std::vector< int >() ) );
 
      // Print the configuration to give some feedback to the user:
      printConfig();
 
      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 870 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 1117 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 821 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 811 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 816 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, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      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 1199 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

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_bgkey

int Trig::StaticBunchCrossingTool::m_bgkey

private

Default key to be loaded.

Definition at line 63 of file StaticBunchCrossingTool.h.

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_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_knownBGKeys

std::map< int, std::vector< int > > Trig::StaticBunchCrossingTool::m_knownBGKeys

private

All the hard-coded configs.

Definition at line 66 of file StaticBunchCrossingTool.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:

• StaticBunchCrossingTool.h
• StaticBunchCrossingTool.cxx