Trig::BunchCrossingToolBase Class Reference

Base class for all BunchCrossingTool implementations. More...

#include <BunchCrossingToolBase.h>

Inheritance diagram for Trig::BunchCrossingToolBase:

Collaboration diagram for Trig::BunchCrossingToolBase:

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. More...

Public Member Functions
	BunchCrossingToolBase (const std::string &name="BunchCrossingToolBase")
	Default constructor. More...
virtual void	print () const =0
	Print the state of the tool. More...
virtual StatusCode	sysInitialize ()
	Function initialising the tool in the correct way in Athena. More...
virtual StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
virtual void	print () const
	Print the state of the tool. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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. More...
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. More...
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. More...
void	printConfig () const
	Function printing the configuration of the tool. More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

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. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
MetaStore_t	m_inputMetaStore
	Object accessing the input metadata store. More...
MetaStore_t	m_outputMetaStore
	Object accessing the output metadata store. More...
bool	m_beginInputFileCalled
	Flag helping to discover when the tool misses the opening of the first input file. More...
bool	m_useIncidents
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Callback functions helping in metadata reading/writing
void	setUseIncidents (const bool flag)
virtual void	handle (const Incident &inc)
	Function receiving incidents from IncidentSvc/TEvent. More...
virtual StatusCode	beginInputFile ()
	Function called when a new input file is opened. More...
virtual StatusCode	endInputFile ()
	Function called when the currently open input file got completely processed. More...
virtual StatusCode	beginEvent ()
	Function called when a new events is loaded. More...
virtual StatusCode	metaDataStop ()
	Function called when the tool should write out its metadata. More...

Detailed Description

Base class for all BunchCrossingTool implementations.

This class holds the logic of the bunch crossing tool. The concrete implementations have to supply it with a vector of the filled bunches and optionally their intensities, which they can get from any location they want.

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

618331

Date

2014-09-24 13:55:26 +0200 (Wed, 24 Sep 2014)

Definition at line 40 of file BunchCrossingToolBase.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

BunchCrossingToolBase()

Trig::BunchCrossingToolBase::BunchCrossingToolBase

(

const std::string &

name = "BunchCrossingToolBase"

)

Default constructor.

The class needs an explicit constructor because some of the member variables really need to be initialized at construction.

Declare the properties of the tool:

Definition at line 21 of file BunchCrossingToolBase.cxx.

      : asg::AsgMetadataTool( name ),
        m_filledBunches(), m_singleBunches(), m_unpairedBunches(),
        m_bunchTrains() {
 
      declareProperty( "MaxBunchSpacing", m_maxBunchSpacing = 150 );
      declareProperty( "FrontLength", m_frontLength = 300 );
      declareProperty( "TailLength", m_tailLength = 300 );
   }

Member Function Documentation

bcIntensity()

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

virtual

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

virtual

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, TrigConf::xAODConfigTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, Trig::TrigDecisionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, Trig::TrigConfBunchCrossingTool, xAODMaker::TriggerMenuMetaDataTool, and Trig::xAODBunchCrossingTool.

Definition at line 196 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, TrigConf::xAODConfigTool, PMGTools::PMGTruthWeightTool, BookkeeperTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, Trig::TrigDecisionTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, Trig::xAODBunchCrossingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, and TauAnalysisTools::TauSmearingTool.

Definition at line 180 of file AsgMetadataTool.cxx.

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

bunchesAfter()

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

virtual

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

virtual

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

virtual

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

virtual

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

private

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

virtual

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() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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

virtual

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

virtual

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 BookkeeperTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 188 of file AsgMetadataTool.cxx.

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

evtStore() [1/2]

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

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 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

virtual

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

virtual

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

virtual

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

virtual

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 130 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()

virtual StatusCode asg::AsgTool::initialize ( )

inlinevirtualinherited

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented in SimpleMuonTriggerScaleFactors, Trig::TrigMuonMatching, CP::MuonTriggerScaleFactors, IHIEventShapeMapTool, ST::SUSYObjDef_xAOD, InDetSecVtxTruthMatchTool, JetGrooming::RecSoftDrop, met::METMaker, AsgForwardElectronIsEMSelector, JetGrooming::JetTrimming, ORUtils::BaseOverlapTool, PMGTools::PMGSherpa22VJetsWeightTool, AsgElectronEfficiencyCorrectionTool, CP::ElectronChargeEfficiencyCorrectionTool, AsgForwardElectronLikelihoodTool, CorrectPFOTool, CP::IsolationCorrectionTool, TauAnalysisTools::TauTruthMatchingTool, EGammaAmbiguityTool, InDetVertexTruthMatchTool, AthOnnx::OnnxRuntimeSessionToolCPU, AthOnnx::OnnxRuntimeSessionToolCUDA, PuppiWeightTool, CP::EgammaCalibrationAndSmearingTool, CP::FFJetSmearingTool, JetBalancePFlowJvtTool, JetIsolationTool, JetForwardPFlowJvtTool, MCTruthClassifier, InDet::InDetHardScatterSelectionTool, dRMatchingTool, xAOD::BPhysBlindingTool, JetVertexTaggerTool, tauRecTools::TrackRNN, LVL1::L1CaloOfflineTriggerTowerTools, TauAnalysisTools::TauSelectionTool, JetRecTool, met::METAssociationTool, CP::TrackVertexAssociationTool, met::METRebuilder, met::METAssociator, xAOD::TrackIsolationTool, InDet::InDetTrackSelectionTool, egammaMVACalibTool, TrigConf::xAODConfigTool, JetCleaningTool, met::METCaloRegionsTool, ZDC::ZdcLEDAnalysisTool, CP::MuonCalibTool, LVL1::L1CaloCells2TriggerTowers, IDTPM::TrackAnalysisInfoWriteTool, JetVertexFractionTool, LVL1BS::PpmByteStreamReadV1V2Tool, ZDC::RpdSubtractCentroidTool, JetClusterer, JetForwardJvtToolBDT, CP::AsgFlagSelectionTool, TauTrackFinder, TauAnalysisTools::DiTauSelectionTool, JetClustererByVertex, JetBadChanCorrTool, xAOD::BPhysTrackVertexMapTool, JetModifiedMassDrop, xAOD::CaloIsolationTool, EnhancedBiasWeighter, BookkeeperTool, InDet::InDetUsedInFitTrackDecoratorTool, CP::AsgPtEtaSelectionTool, TauAnalysisTools::BuildTruthTaus, tauRecTools::TauTrackRNNClassifier, InDet::InDetSecVtxTrackSelectionTool, JetForwardJvtTool, JetPileupTag::JetVertexNNTagger, CP::EgammaIsGoodOQSelectionTool, CP::IsolationCloseByCorrectionTool, CP::MuonCalibIntScaleSmearTool, DiTauRecTools::DiTauIDVarCalculator, JetFinder, AsgElectronIsEMSelector, CP::MuonCalibIntHighpTSmearTool, CP::MuonCalibIntSagittaTool, DiTauRecTools::DiTauDiscriminantTool, met::METBuilderTool, CP::AsgMaskSelectionTool, ElectronPhotonVariableCorrectionBase, ECUtils::EventCleaningTool, TauAnalysisTools::TauTruthTrackMatchingTool, met::METSoftTermsTool, LVL1::L1CaloLArTowerEnergy, HiggsTruthCategoryTool, IDTPM::TrackRoiSelectionTool, TauAnalysisTools::CommonDiTauEfficiencyTool, HIJetConstituentSubtractionTool, JetTrackSumMomentsTool, JetGrooming::SoftDrop, JetTrackMomentsTool, met::METTruthTool, PMGTools::PMGSherpaVjetsSysTool, JetQGTaggerVariableTool, ClusterMatching::CaloClusterMatchingTool, AsgPhotonEfficiencyCorrectionTool, FlavorTagDiscriminants::MultifoldGNNTool, InDet::JetTrackFilterTool, asg::DataHandleTestTool, xAODMaker::FileMetaDataTool, InDet::InclusiveTrackFilterTool, InDet::InDetTrackTruthFilterTool, HIJetClusterSubtractorTool, CP::MVATrackVertexAssociationTool, IDTPM::RoiSelectionTool, CP::BaseFakeBkgTool, ElectronPhotonVariableCorrectionTool, JetCalibrationTool, JetCaloQualityTool, JetOriginCorrectionTool, IDTPM::TrackObjectSelectionTool, InDet::InDetTrackBiasingTool, HIJetClusterIndexAssociationTool, TauWPDecorator, TrigGlobalEfficiencyCorrectionTool, ZdcRecChannelToolV2, InDetGNNHardScatterSelection::GNNTool, CP::BaseLinearFakeBkgTool, FlavorTagDiscriminants::GNNTool, CP::MuonSelectionTool, TauAnalysisTools::CommonDiTauSmearingTool, JSSTaggerBase, IDTPM::TrackQualitySelectionTool, CP::LhoodMM_tools, AsgElectronLikelihoodTool, CP::JetQGTagger, CP::JetJvtEfficiency, LVL1::L1CaloFcal23Cells2RxMappingTool, ORUtils::OverlapRemovalTool, Ringer::AsgRingerSelectorTool, InDet::InDetTrackSmearingTool, JetCopier, JetGrooming::JetGroomer, met::METPhotonAssociator, Pileup1DResidualCalibStep, JetECPSFractionTool, JetPtAssociationTool, met::METElectronAssociator, met::METTauAssociator, PMGTools::PMGDecayProductsSelectionTool, WeightToolBase, HIJetDRAssociationTool, JetClusterMomentsTool, met::METJetAssocTool, TauVertexFinder, IDTPM::JsonPlotsDefReadTool, TauAnalysisTools::DiTauSmearingTool, BJetCorrectionTool, JetDRTrackAssocTool, JetReclusterer, TauDecayModeNNClassifier, BDTVertexWeightCalculator, asg::UnitTestTool1, ZDC::ZdcAnalysisTool, IDTPM::DeltaRMatchingToolBase< T, R >, AsgElectronSelectorTool, GSCCalibStep, EtaMassJESCalibStep, JetReclusteringTool, met::METMuonAssociator, TauPi0CreateROI, TauShotFinder, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle, xAOD::TruthParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TruthParticle, xAOD::TrackParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle >, ZdcRecChannelToolLucrod, PMGTools::PMGTruthWeightTool, JetCalibTool, SmearingCalibStep, JetVoronoiMomentsTool, Trig::MatchFromCompositeTool, asg::UnitTestTool3, IDTPM::TruthTrackMatchingTool, CP::ApplyFakeFactor, AsgElectronChargeIDSelectorTool, HIJetMaxOverMeanTool, PanTau::Tool_FeatureExtractor, TauElectronVetoVariables, ZDC::ZdcTrigValidTool, CP::IsolationSelectionTool, WeightsAgregator, EL::UnitTestTool, FlavorTagDiscriminants::TrackClassifier, JetLArHVTool, IDTPM::EFTrackMatchingTool, IDTPM::TrackTruthMatchingTool, HI::HIPileupTool, BTaggingSelectionTool, InDet::InDetTrackTruthOriginTool, JetHelper::VarTool, FlavorTagDiscriminants::DL2Tool, PileupAreaCalibStep, EnergyCorrelatorGeneralizedRatiosTool, EnergyCorrelatorGeneralizedTool, EnergyCorrelatorRatiosTool, EnergyCorrelatorTool, TauEleOverlapChecker, TauJetRNNEvaluator, asg::UnitTestTool2, JetTruthLabelingTool, ZDC::ZdcRecTool, HIJetConstituentModifierTool, TauCalibrateLC, TauGNNEvaluator, TauPi0ScoreCalculator, TauRecToolBase, Trig::TrigEgammaEmulationPrecisionElectronHypoTool, asg::UnitTestTool1A, IDTPM::TruthQualitySelectionTool, PDFWeight, HIEventShapeJetIteration, HIJetSignificanceTool, CP::JetQGTaggerBDT, JetWidthTool, TauVertexVariables, Trig::TrigEgammaEmulationPrecisionPhotonHypoTool, Trig::TrigEgammaMatchingTool, Trig::R3IParticleRetrievalTool, JetPileupLabelingTool, JetFromPseudojet, JetTruthParticleSelectorTool, Trig::TrigEgammaEmulationBaseHypoTool, AthOnnx::OnnxRuntimeInferenceTool, ZDC::RPDAnalysisTool, CP::ApplyE2YFakeRate, ParticleScaleFactorTool, InDet::InDetTrackSystematicsTool, JetCaloQualityToolFE, Trig::MatchingTool, Trig::R3MatchingTool, IDTPM::OfflineTrackQualitySelectionTool, JetParticleAssociation, Trig::TrigEgammaEmulationChain, Trig::TrigEgammaEmulationFastCaloHypoTool, xAODtoHepMCTool, HIEventShapeMapTool, HI::HIVertexSelectionTool, JetHelper::HistoInput2D, TauVertexedClusterDecorator, Trig::IParticleRetrievalTool, HI::HIEventSelectionTool, FlavorTagDiscriminants::HbbTagTool, JetConstituentFrac, JetGroomMRatio, Validator, JetHelper::HistoInput1D, JetHelper::TextInputMCJES, ExtendTrackToLayerTool, Trig::TypedScoringTool, TrackTruthSelectionTool, HIUEModulatorTool, JSSWTopTaggerANN, CP::JvtEfficiencyToolBase, JetEMScaleMomTool, MvaTESVariableDecorator, TauAODLeptonRemovalTool, TauCombinedTES, CP::AsymptMatrixTool, ParticleJetDeltaRLabelTool, HIEventShapeSummaryTool, FlavorTagDiscriminants::BTagAugmenterTool, FlavorTagDiscriminants::VRJetOverlapDecoratorTool, JetCaloEnergies, ParticleJetGhostLabelTool, FlavorTagDiscriminants::BTagMuonAugmenterTool, BTaggingEfficiencyJsonTool, MBTSTimeFilterTool, JSSWTopTaggerDNN, SmoothedTopTagger, MvaTESEvaluator, CP::IsolationLowPtPLVTool, Trig::DRScoringTool, Trig::EgammaDRScoringTool, BTaggingSelectionJsonTool, SmoothedWZTagger, CP::FJvtEfficiencyTool, CP::JvtSelectionToolBase, CP::NNJvtSelectionTool, AthAsgExUnittestTool, CP::JvtSelectionTool, CP::FJvtSelectionTool, CP::JvtEfficiencyTool, CP::NNJvtEfficiencyTool, BookkeeperDumperTool, TrigFastCalibWithRings, BTaggingEfficiencyTool, BTaggingTruthTaggingTool, MissingCellListTool, JetVoronoiDiagramHelpers::Diagram, FastJetInterfaceTool, CP::PhotonVertexSelectionTool, met::METSystematicsTool, Trig::TrigEgammaEmulationToolMT, JetAttributeRatioSelector, BTaggingEigenVectorRecompositionTool, Trig::TrigDecisionTool, CP::PhotonPointingTool, met::METRecoTool, ZdcByteStreamReadV1V2Tool, CP::PileupReweightingTool, LVL1::L1CaloxAODOfflineTriggerTowerTools, LVL1::TrigT1CaloMonErrorToolV1, met::METTrackFilterTool, LVL1::TrigT1CaloMonErrorTool, SoftKillerWeightTool, EventDensityTool, met::METSignificance, JetUncertaintiesTool, CP::JetTileCorrectionTool, xAODMaker::TriggerMenuMetaDataTool, D3PD::D3PDMCTruthClassifier, JetConstituentModSequence, HistoGroupBase, AsgPhotonIsEMSelector, JetAttributeSelector, TrackVertexAssociationTool, met::METRefinerTool, TauAnalysisTools::CommonSmearingTool, PanTau::Tool_DetailsArranger, LVL1::L1CaloMonitoringCaloTool, LVL1::L1CaloTTIdTools, JetInputElRemovalTool, TauAnalysisTools::CommonEfficiencyTool, PanTau::PanTauProcessor, xAODMaker::TruthMetaDataTool, EventShapeCopier, met::METJetTool, GoodRunsListSelectionTool, FSR::FsrPhotonTool, Trig::StaticBunchCrossingTool, ZMassConstraint::ConstraintFit, TauAnalysisTools::TauEfficiencyCorrectionsTool, PanTau::Tool_DecayModeDeterminator, PanTau::Tool_ModeDiscriminator, CP::ElectronLRTOverlapRemovalTool, HIClusterSubtraction, JetAttributeHisto, JetPseudojetCopier, met::METEgammaAssociator, Trig::xAODBunchCrossingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauTruthMatchingTool, TauAnalysisTools::TauSmearingTool, met::METTruthAssociator, PanTau::Tool_InformationStore, HistoDefinitionTool, PanTau::Tool_InputConverter, DiTauMassTools::MissingMassTool, JetBottomUpSoftDrop, JetRecursiveSoftDrop, PMGTools::PMGCrossSectionTool, JetSoftDrop, TrigEgammaMatchingToolMT, JetConstituentsRetriever, VoronoiWeightTool, JetCaloCellQualityTool, JetContainerHistoFiller, ChargedHadronSubtractionTool, met::METRegionsTool, met::METSoftAssociator, PanTau::Tool_TauConstituentGetter, ConstituentSubtractorTool, JetHistoBase, JetSelectorAttributeRunII, JetSplitter, CaloClusterConstituentsOrigin, CP::MuonLRTOverlapRemovalTool, HistosForJetSelection, JetPruner, JetToolRunner, JetUsedInFitTrackDecoratorTool, JetTrimmer, NSubjettinessRatiosTool, CP::MuonEfficiencyScaleFactors, JetConstitFourMomTool, NSubjettinessTool, ZdcDataAccessV2, JetPseudojetRetriever, LVL1BS::TrigT1CaloDataAccessV2, PanTau::Tool_TauConstituentSelector, CopyTruthParticles, ClusterAtEMScaleTool, CP::IsolationHelper, AsgDeadHVCellRemovalTool, EfficiencyResponseHistos, ConstitTimeCutTool, JetSelectorAttribute, HIJetUEMonitoring, HIEfficiencyResponseHistos, JetSubStructureMomentToolsBase, AsgHelloTool, CopyTruthJetParticles, LeadingJetsRelations, and JetEventSelector.

Definition at line 133 of file AsgTool.h.

{ 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 88 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

virtual

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

virtual

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

virtual

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

virtual

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

virtual

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 >()  )

protected

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

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 >()  )

protected

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 >()  )

protected

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 xAODMaker::FileMetaDataTool, BookkeeperTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 204 of file AsgMetadataTool.cxx.

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

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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

virtual

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

virtual

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

virtual

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 97 of file AsgMetadataTool.cxx.

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

print() [1/2]

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

print() [2/2]

virtual void asg::IAsgTool::print ( ) const

pure virtualinherited

Print the state of the tool.

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

printConfig()

void Trig::BunchCrossingToolBase::printConfig ( ) const

protected

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 110 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_bunchTrains

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

protected

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

protected

List of colliding bunches.

Definition at line 150 of file BunchCrossingToolBase.h.

m_frontLength

int Trig::BunchCrossingToolBase::m_frontLength

protected

Length of the "front" of a bunch train.

Definition at line 166 of file BunchCrossingToolBase.h.

m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore

privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

m_maxBunchSpacing

int Trig::BunchCrossingToolBase::m_maxBunchSpacing

protected

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

protected

Internal list of single bunches.

Definition at line 152 of file BunchCrossingToolBase.h.

m_tailLength

int Trig::BunchCrossingToolBase::m_tailLength

protected

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

protected

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:

• BunchCrossingToolBase.h
• BunchCrossingToolBase.cxx