Providing information separately for beam 1 and beam 2 now (TrigAnalysisInterfaces-00-02-00)

Trigger/TrigAnalysis/TrigAnalysisInterfaces/Root/LinkDef.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: LinkDef.h 457108 2011-09-05 09:14:09Z krasznaa $
+#ifdef __CINT__
+
+#include "../TrigAnalysisInterfaces/IIBunchCrossingTool.h"
+
+// This pretty empty LinkDef file is here to create a small RootCore
+// library out of this interface package. This is just a hack,
+// in the future a better solution might be found. (This dictionary
+// is not necessarily needed...)
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ nestedclass;
+
+#pragma link C++ class Trig::IIBunchCrossingTool+;
+
+#endif // __CINT__

Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingConfProvider.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: IBunchCrossingConfProvider.h 511861 2012-07-31 08:40:04Z krasznaa $
+#ifndef TRIGANALYSISINTERFACES_IBUNCHCROSSINGCONFPROVIDER_H
+#define TRIGANALYSISINTERFACES_IBUNCHCROSSINGCONFPROVIDER_H
+
+// STL include(s):
+#include <vector>
+
+// Gaudi/Athena include(s):
+#include "GaudiKernel/IAlgTool.h"
+
+namespace Trig {
+
+   /// The interface provided by IBunchCrossingConfProvider
+   static const InterfaceID
+   IID_IBunchCrossingConfProvider( "Trig::IBunchCrossingConfProvider", 2, 0 );
+
+   /**
+    *  @short Inteface for providing the bunch structure information
+    *
+    *         To make it simpler for Athena components to save the bunch
+    *         structure information in a uniform way, they should use this
+    *         interface. The bunch structure configuration can come from many
+    *         different places. Since the package already provides code for
+    *         interpreting all these sources, it makes sense that analysts
+    *         wouldn't have to re-do all this themselves.
+    *
+    *         The idea is that the information that this interface provides has
+    *         to be enough for fully configuring any version (especially the
+    *         standalone one(s)) of the tool. The main use case at the moment
+    *         being, that if someone saves this configuration into a D3PD, it
+    *         will become possible to use a standalone version of the bunch
+    *         crossing tool to analyse the D3PD in the same way as the analysis
+    *         is done in Athena.
+    *
+    *         This interface is not split into an Athena-dependent and
+    *         Athena-independent class, as I don't think this functionality
+    *         would be useful outside Athena. But who knows...
+    *
+    *         All Athena tools that implement this interface have to fire an
+    *         incident of type "BunchConfig" when their configuration is
+    *         updated. Unfortunately I can't create a static member with this
+    *         type name, because then the interface would stop being pure
+    *         virtual... :-( I could define this incident type name as a
+    *         pre-processor macro, but I don't like that solution. :-P
+    *
+    * @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+    *
+    * $Revision: 511861 $
+    * $Date: 2012-07-31 10:40:04 +0200 (Tue, 31 Jul 2012) $
+    */
+   class IBunchCrossingConfProvider : public virtual IAlgTool {
+
+   public:
+      /// Virtual destructor to make the vtable happy
+      virtual ~IBunchCrossingConfProvider() {}
+
+      /// Gaudi interface definition
+      static const InterfaceID& interfaceID() {
+         return IID_IBunchCrossingConfProvider;
+      }
+
+      /// Type for the unique identifier
+      typedef unsigned int configid_type;
+
+      /// Unique identifier for the current configuration
+      /**
+       * This is a tricky part of the interface. In order to be able to save
+       * the bunch pattern configuration for many different setups in a
+       * meaningful way, we have to uniquely identify each differing
+       * configuration.
+       *
+       * For some backends this is easy. When reading the configuration from
+       * the trigger database, the unique identifier can be the bunch group key
+       * (BGK). But when reading the configuration of a MC file, the situation
+       * is a bit more tricky.
+       *
+       * In the end the only requirement with this function is that it should
+       * return the same ID for two identical configurations, and that it should
+       * return a differiod ID with a "high enough" period for different
+       * configurations.
+       *
+       * @returns A unique identifier for the currently loaded configuration
+       */
+      virtual configid_type configID() const = 0;
+
+      /// Function providing the BCIDs of the configured colliding bunches
+      /**
+       * This function returns the BCIDs of the colliding bunches in the current
+       * configuration.
+       *
+       * @returns The BCIDs of the colliding bunches
+       */
+      virtual std::vector< int > configuredBCIDs() const = 0;
+
+      /// Function providing the intensities of the configured colliding bunches
+      /**
+       * This function returns the "intensities" of the colliding bunches. It
+       * always gives the "intensities" in the same order as the
+       * configuredBCIDs() function returns the BCIDs in. The returned
+       * values may be context specific.
+       *
+       * @returns The "intensities" of the colliding bunches (from beam 1)
+       */
+      virtual std::vector< float > configuredIntensitiesBeam1() const = 0;
+
+      /// Function providing the intensities of the configured colliding bunches
+      /**
+       * This function returns the "intensities" of the colliding bunches. It
+       * always gives the "intensities" in the same order as the
+       * configuredBCIDs() function returns the BCIDs in. The returned
+       * values may be context specific.
+       *
+       * @returns The "intensities" of the colliding bunches (from beam 2)
+       */
+      virtual std::vector< float > configuredIntensitiesBeam2() const = 0;
+
+      /// Function providing the BCIDs of the configured unpaired bunches
+      /**
+       * This function returns the BCIDs of the unpaired bunches in the current
+       * configuration.
+       *
+       * @returns The BCIDs of the unpaired bunches from beam 1
+       */
+      virtual std::vector< int > configuredUnpairedBCIDsBeam1() const = 0;
+
+      /// Function providing the BCIDs of the configured unpaired bunches
+      /**
+       * This function returns the BCIDs of the unpaired bunches in the current
+       * configuration.
+       *
+       * @returns The BCIDs of the unpaired bunches from beam 2
+       */
+      virtual std::vector< int > configuredUnpairedBCIDsBeam2() const = 0;
+
+      /// Function providing the intensities of the configured unpaired bunches
+      /**
+       * This function returns the "intensities" of the unpaired bunches. It always
+       * gives the "intensities" in the same order as the configuredUnpairedBCIDs()
+       * function returns the BCIDs in.
+       *
+       * @returns The "intensities" of the unpaired bunches from beam 1
+       */
+      virtual std::vector< float > configuredUnpairedIntensitiesBeam1() const = 0;
+
+      /// Function providing the intensities of the configured unpaired bunches
+      /**
+       * This function returns the "intensities" of the unpaired bunches. It always
+       * gives the "intensities" in the same order as the configuredUnpairedBCIDs()
+       * function returns the BCIDs in.
+       *
+       * @returns The "intensities" of the unpaired bunches from beam 2
+       */
+      virtual std::vector< float > configuredUnpairedIntensitiesBeam2() const = 0;
+
+   }; // class IBunchCrossingConfProvider
+
+} // namespace Trig
+
+#endif // TRIGANALYSISINTERFACES_IBUNCHCROSSINGCONFPROVIDER_H

Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingTool.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: IBunchCrossingTool.h 511861 2012-07-31 08:40:04Z krasznaa $
+#ifndef TRIGANALYSISINTERFACES_IBUNCHCROSSINGTOOL_H
+#define TRIGANALYSISINTERFACES_IBUNCHCROSSINGTOOL_H
+
+// Gaudi/Athena include(s):
+#include "GaudiKernel/IAlgTool.h"
+
+// Local include(s):
+#include "IIBunchCrossingTool.h"
+
+/**
+ *  @short The common trigger namespace for trigger analysis tools
+ *
+ *         This is the common namespace that all trigger analysis tools use by
+ *         convention.
+ *
+ * $Revision: 511861 $
+ * $Date: 2012-07-31 10:40:04 +0200 (Tue, 31 Jul 2012) $
+ */
+namespace Trig {
+
+   /// The interface provided by IBunchCrossingTool
+   static const InterfaceID IID_IBunchCrossingTool( "Trig::IBunchCrossingTool", 2, 0 );
+
+   /**
+    *  @short Interface for all the bunch crossing tools
+    *
+    *         This is the Athena inteface of all the bunch crossing tools. It inherits
+    *         all its functions from Trig::IIBunchCrossingTool to provide the users
+    *         with the same interface in Athena and outside of it.
+    *
+    *    @see Trig::IIBunchCrossingTool
+    *
+    * @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+    *
+    * $Revision: 511861 $
+    * $Date: 2012-07-31 10:40:04 +0200 (Tue, 31 Jul 2012) $
+    */
+   class IBunchCrossingTool : public virtual IAlgTool,
+                              public virtual IIBunchCrossingTool {
+
+   public:
+      /// Gaudi interface definition
+      static const InterfaceID& interfaceID() { return IID_IBunchCrossingTool; }
+
+   }; // class IBunchCrossingTool
+
+} // namespace Trig
+
+#endif // TRIGANALYSISINTERFACES_IBUNCHCROSSINGTOOL_H

Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IIBunchCrossingTool.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: IIBunchCrossingTool.h 511861 2012-07-31 08:40:04Z krasznaa $
+#ifndef TRIGANALYSISINTERFACES_IIBUNCHCROSSINGTOOL_H
+#define TRIGANALYSISINTERFACES_IIBUNCHCROSSINGTOOL_H
+
+// STL include(s):
+#include <vector>
+
+namespace Trig {
+
+   /**
+    *  @short Framework independent interface for the tools
+    *
+    *         Since some of the code has to be compilable without Athena, this interface
+    *         takes care of making sure that that is possible.
+    *
+    * @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+    *
+    * $Revision: 511861 $
+    * $Date: 2012-07-31 10:40:04 +0200 (Tue, 31 Jul 2012) $
+    */
+   class IIBunchCrossingTool {
+
+   public:
+      /// Convenience type definition
+      typedef unsigned int bcid_type;
+
+      /// Virtual destructor to make the vtable happy...
+      virtual ~IIBunchCrossingTool() {}
+
+      /// The simplest query: Is the bunch crossing filled or not?
+      /**
+       * This is the simplest question that one can ask the configuration:
+       * Was the current BCID coming from a collision or not? If people
+       * properly use the triggers to select their events, then this function
+       * is not too useful, but for some special analyses it might be a good
+       * idea to have it.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns <code>true</code> if the bcid was a collision bunch crossing,
+       *          <code>false</code> otherwise
+       */
+      virtual bool isFilled( bcid_type bcid = 0 ) const = 0;
+
+      /// Function deciding if a given bunch crossing is in a filled train
+      /**
+       * Most of the functionality of the interface only makes sense for bunches
+       * which were in trains. So this function can be checked at the beginning
+       * of the analysis code, to make sure that the BC in question is interesting.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns <code>true</code> if the bcid is part of a bunch train,
+       *          <code>false</code> otherwise
+       */
+      virtual bool isInTrain( bcid_type bcid = 0 ) const = 0;
+
+      /// Function deciding if a given bunch crossing has an unpaired bunch
+      /**
+       * This function can be used to quickly decide whether the current event
+       * came from an unpaired bunch. Note that the function doesn't make a difference
+       * between "isolated" and "non isolated" unpaired bunches. You have to use
+       * the <code>gapBeforeBunch</code> function to decide how isolated an
+       * unpaired bunch is.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns <code>true</code> if the bcid belongs to an unpaired bunch,
+       *          <code>false</code> otherwise
+       */
+      virtual bool isUnpaired( bcid_type bcid = 0 ) const = 0;
+
+      /// Function deciding if there was a bunch from "beam 1" in this bunch crossing
+      /**
+       * This function is useful for differentiating the unpaired bunch
+       * crossings based on which beam provided the unpaired bunch.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns <code>true</code> if the bcid contained a bunch from beam 1,
+       *          <code>false</code> otherwise
+       */
+      virtual bool isBeam1( bcid_type bcid = 0 ) const = 0;
+
+      /// Function deciding if there was a bunch from "beam 2" in this bunch crossing
+      /**
+       * This function is useful for differentiating the unpaired bunch
+       * crossings based on which beam provided the unpaired bunch.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns <code>true</code> if the bcid contained a bunch from beam 2,
+       *          <code>false</code> otherwise
+       */
+      virtual bool isBeam2( bcid_type bcid = 0 ) const = 0;
+
+      /// 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.
+       */
+      enum BeamType {
+         Beam1    = 0, ///< The returned intensity should be for "beam 1"
+         Beam2    = 1, ///< The returned intensity should be for "beam 2"
+         Crossing = 2  ///< The returned intensity should describe the BC
+      };
+
+      /// Function returning the "intensity" of a given bunch(-crossing)
+      /**
+       * Some imeplementations are able to return an "intensity" per BCID.
+       * The exact meaning of this intensity is actually context sensitive,
+       * as it could mean quite different things for pile-up MC and data
+       * samples.
+       *
+       * The tool implementations that don't know about the bunch intensities
+       * will return 1.0 for filled bunch crossings and 0.0 for empty ones.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns The "intensity" of the bcid in question
+       */
+      virtual float bcIntensity( bcid_type bcid = 0,
+                                 BeamType type = Crossing ) const = 0;
+
+      /// 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.
+       */
+      enum BunchCrossingType {
+         Empty = 0, ///< An empty bunch far away from filled bunches
+         FirstEmpty = 1, ///< The first empty bunch after a train
+         MiddleEmpty = 2, ///< An empty BCID in the middle of a train
+         Single = 100, ///< This is a filled, single bunch (not in a train)
+         Front = 200, ///< The BCID belongs to the first few bunches in a train
+         Middle = 201, ///< The BCID belongs to the middle bunches in a train
+         Tail = 202, ///< The BCID belongs to the last few bunces in a train
+         Unpaired = 300 ///< This is an unpaired bunch (either beam1 or beam2)
+      };
+
+      /// Get the type of the specific bunch crossing
+      /**
+       * This function could be used as a single entry point to this tool in principle.
+       * It gives a summary about a specific BCID. Remember however that the exact
+       * meaning of many of the return values of this function are configuration
+       * dependent.
+       *
+       * @param bcid The bcid that should be checked
+       * @returns The type of the bcid in question
+       */
+      virtual BunchCrossingType bcType( bcid_type bcid = 0 ) const = 0;
+
+      /// 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.
+       */
+      enum BunchDistanceType {
+         NanoSec, ///< Distance in nanoseconds
+         BunchCrossings, ///< Distance in units of 25 nanoseconds
+         FilledBunches ///< Distance in units of filled bunches (depends on filling scheme)
+      };
+
+      /// The distance of the specific bunch crossing from the front of the train
+      /**
+       * Get the distance of the specified bunch crossing from the front of the
+       * bunch train. If the specified bunch crossing is not part of a bunch train,
+       * then the function returns -1.
+       *
+       * The distance can be returned in multiple units. By default it is returned in
+       * nanoseconds. If one specifies BunchCrossings, then the distance is returned in
+       * nanosec_distance / 25. Finally, if one specifies FilledBunches, then the
+       * distance is returned in the units of the bunch spacing within the train.
+       *
+       * @param bcid The bcid that should be checked
+       * @param type The type of the requested return value
+       * @returns The distance of the bcid in question from the front of its bunch train
+       */
+      virtual int distanceFromFront( bcid_type bcid = 0,
+                                     BunchDistanceType type = NanoSec ) const = 0;
+      /// The distance of the specific bunch crossing from the tail of the train
+      /**
+       * Get the distance of the specified bunch crossing from the tail of the
+       * bunch train. If the specified bunch crossing is not part of a bunch train,
+       * then the function returns -1.
+       *
+       * The distance can be returned in multiple units. By default it is returned in
+       * nanoseconds. If one specifies BunchCrossings, then the distance is returned in
+       * nanosec_distance / 25. Finally, if one specifies FilledBunches, then the
+       * distance is returned in the units of the bunch spacing within the train.
+       *
+       * @param bcid The bcid that should be checked
+       * @param type The type of the requested return value
+       * @returns The distance of the bcid in question from the tail of its bunch train
+       */
+      virtual int distanceFromTail( bcid_type bcid = 0,
+                                    BunchDistanceType type = NanoSec ) const = 0;
+
+      /// Gap before the train this BCID is in
+      /**
+       * Get the gap that's between the train that the specified BCID is in, and the
+       * previous train. This is a useful number for some jet/MET studies.
+       *
+       * Note that the function doesn't work with the FilledBunches type, as the size
+       * of the gaps doesn't have to be a multiple of the bunch distance within the
+       * trains.
+       *
+       * Returns "-1" when there's no right answer to the question. (BCID not part
+       * of a train.)
+       *
+       * @param bcid The bcid whose train should be investigated
+       * @param type The type of the requested return value
+       * @returns The gap before the train of the specified bcid
+       */
+      virtual int gapBeforeTrain( bcid_type bcid = 0,
+                                  BunchDistanceType type = NanoSec ) const = 0;
+      /// Gap after the train this BCID is in
+      /**
+       * Get the gap that's between the train that the specified BCID is in, and the
+       * next train. This is a useful number for some jet/MET studies.
+       *
+       * Note that the function doesn't work with the FilledBunches type, as the size
+       * of the gaps doesn't have to be a multiple of the bunch distance within the
+       * trains.
+       *
+       * Returns "-1" when there's no right answer to the question. (BCID not part
+       * of a train.)
+       *
+       * @param bcid The bcid whose train should be investigated
+       * @param type The type of the requested return value
+       * @returns The gap after the train of the specified bcid
+       */
+      virtual int gapAfterTrain( bcid_type bcid = 0,
+                                 BunchDistanceType type = NanoSec ) const = 0;
+
+      /// 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.
+       */
+      enum BunchFillType {
+         CollidingBunch = 0, ///< The gap should be calculated wrt. the closest colling bunch
+         UnpairedBunch  = 1, ///< The gap should be calculated wrt. the closest unpaired bunch
+         EmptyBunch     = 2, ///< The gap should be calculated wrt. the closest empty bunch
+         UnpairedBeam1  = 3, ///< The gap should be calculated wrt. the closest unpaired bunch from beam 1
+         UnpairedBeam2  = 4  ///< The gap should be calculated wrt. the closest unpaired bunch from beam 2
+      };
+
+      /// Gap before a particular bunch
+      /**
+       * The function tells you how far the BCID in question is from the previous
+       * colliding bunch crossing.
+       *
+       * @param bcid The bcid that should be investigated
+       * @param dtype The type of the requested return value
+       * @param ftype The type of the previous bunch to consider
+       * @returns The gap before the specified bcid
+       */
+      virtual int gapBeforeBunch( bcid_type bcid = 0,
+                                  BunchDistanceType dtype = NanoSec,
+                                  BunchFillType ftype = CollidingBunch ) const = 0;
+
+      /// Gap after a particular bunch
+      /**
+       * The function tells you how far the BCID in question is from the next
+       * colliding bunch crossing.
+       *
+       * @param bcid The bcid that should be investigated
+       * @param dtype The type of the requested return value
+       * @param ftype The type of the previous bunch to consider
+       * @returns The gap after the specified bcid
+       */
+      virtual int gapAfterBunch( bcid_type bcid = 0,
+                                 BunchDistanceType dtype = NanoSec,
+                                 BunchFillType ftype = CollidingBunch ) const = 0;
+
+      /// Function returning whether the previous bunches were filled, and how
+      /**
+       * To get a concrete idea of how the bunch structure looks like in front of the
+       * bcid under investigation, this function returns a vector representing the
+       * previous bunches.
+       *
+       * The indexing is such that <code>return[0]</code> means the reference bunch,
+       * <code>return[1]</code> means the first bunch before that one, etc.
+       * The boolean value <code>true</code> means that the bunch was filled,
+       * <code>false</code> means that is was empty.
+       *
+       * It's really just another way of getting the same information as what
+       * isFilled(...) is providing...
+       *
+       * @param bcid The bcid that should be checked
+       * @param bunches The number of bunches about which the return value should have info
+       * @returns The bunch pattern before the reference bunch
+       */
+      virtual std::vector< bool > bunchesInFront( bcid_type bcid = 0,
+                                                  int bunches = 10 ) const = 0;
+
+      /// Function returning whether the following bunches were filled, and how
+      /**
+       * This function is here to provide uniformity between the python and C++
+       * implementations. It works pretty much like the bunchesInFron(...) function.
+       *
+       * The indexing is such that <code>return[0]</code> means the reference bunch,
+       * <code>return[1]</code> means the first bunch after that one, etc.
+       * The boolean value <code>true</code> means that the bunch was filled,
+       * <code>false</code> means that is was empty.
+       *
+       * It's really just another way of getting the same information as what
+       * isFilled(...) is providing...
+       *
+       * @param bcid The bcid that should be checked
+       * @param bunches The number of bunches about which the return value should have info
+       * @returns The bunch pattern after the reference bunch
+       */
+      virtual std::vector< bool > bunchesAfter( bcid_type bcid = 0,
+                                                int bunches = 10 ) const = 0;
+
+      /// Function returning the intensities of the bunch crossings before the reference
+      /**
+       * In some cases one does not only want to know if the previous bunches were filled,
+       * but also their intensities. This intensity has a context sensitive meaning, as
+       * the MC and data bunch intensities can't be directly compared in general, but in
+       * both cases the intensities are described by floating point numbers.
+       *
+       * The indexing is the same as with the bunchesInFront(...) function.
+       *
+       * @param bcid The bcid that should be checked
+       * @param bunches The number of bunches about which the return value should have info
+       * @param type The intensity "type" the user is interested in
+       * @returns The intensities of the bunch crossings in front of the reference BC
+       */
+      virtual std::vector< float > bunchIntInFront( bcid_type bcid = 0,
+                                                    int bunches = 10,
+                                                    BeamType type = Crossing ) const = 0;
+
+      /// Function returning the intensities of the bunch crossings after the reference
+      /**
+       * In some cases one does not only want to know if the following bunches were filled,
+       * but also their intensities. This intensity has a context sensitive meaning, as
+       * the MC and data bunch intensities can't be directly compared in general, but in
+       * both cases the intensities are described by floating point numbers.
+       *
+       * The indexing is the same as with the bunchesAfter(...) function.
+       *
+       * @param bcid The bcid that should be checked
+       * @param bunches The number of bunches about which the return value should have info
+       * @param type The intensity "type" the user is interested in
+       * @returns The intensities of the bunch crossings after of the reference BC
+       */
+      virtual std::vector< float > bunchIntAfter( bcid_type bcid = 0,
+                                                  int bunches = 10,
+                                                  BeamType type = Crossing ) const = 0;
+
+      /// Get the number of filled bunches in the current configuration
+      /**
+       * This function gives the total number of filled (colliding) bunches in the current
+       * configuration. This could come in handy in some circumstances.
+       *
+       * @returns The total number of filled (colliding) bunches in the machine
+       */
+      virtual unsigned int numberOfFilledBunches() const = 0;
+
+      /// Get the number of unpaired bunches in the current configuration
+      /**
+       * This function gives the total number of unpaired bunches in the current
+       * configuration. This could come in handy in some circumstances.
+       *
+       * @returns The total number of unpaired bunches in the machine
+       */
+      virtual unsigned int numberOfUnpairedBunches() const = 0;
+
+      /// Get the number of the bunch trains in the current configuration
+      /**
+       * This function gives the total number of bunch trains that were identified in
+       * the current configuration. This could come in handy in some circumstances.
+       *
+       * @returns The total number of bunch trains in the machine
+       */
+      virtual unsigned int numberOfBunchTrains() const = 0;
+
+      /// Get the bunch spacing in the trains
+      /**
+       * This function can be used to easily find out what was the bunch spacing in the
+       * bunch trains. This could come in handy in some circumstances.
+       *
+       * Note that a return value type of <code>FilledBunches</code> makes no sense,
+       * so the code will complain if you request the value with that parameter.
+       *
+       * @param type The type of the requested return value
+       * @returns The bunch spacing in the requested units
+       */
+      virtual int bunchTrainSpacing( BunchDistanceType type = NanoSec ) const = 0;
+
+   }; // class IIBunchCrossingTool
+
+} // namespace Trig
+
+#endif // TRIGANALYSISINTERFACES_IIBUNCHCROSSINGTOOL_H

Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/TrigAnalysisInterfacesDict.h

+// Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: TrigAnalysisInterfacesDict.h 360786 2011-04-21 11:30:18Z krasznaa $
+#ifndef TRIGANALYSISINTERFACES_TRIGANALYSISINTERFACESDICT_H
+#define TRIGANALYSISINTERFACES_TRIGANALYSISINTERFACESDICT_H
+
+// Include all the headers which contain classes for which we want to generate
+// Reflex dictionaries:
+#include "TrigAnalysisInterfaces/IIBunchCrossingTool.h"
+#include "TrigAnalysisInterfaces/IBunchCrossingTool.h"
+#include "TrigAnalysisInterfaces/IBunchCrossingConfProvider.h"
+
+#endif // TRIGANALYSISINTERFACES_TRIGANALYSISINTERFACESDICT_H

Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/selection.xml

+<!-- $Id: selection.xml 360786 2011-04-21 11:30:18Z krasznaa $ -->
+<lcgdict>
+
+   <!-- The interfaces for which we need a Reflex dictionary: -->
+   <class name="Trig::IIBunchCrossingTool" />
+   <class name="Trig::IBunchCrossingTool" />
+   <class name="Trig::IBunchCrossingConfProvider" />
+
+</lcgdict>

Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/Makefile.RootCore

+# Dear emacs, this is a -*- Makefile -*-
+# Author: Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+# TrigAnalysisInterfaces makefile for the RootCore environment
+
+PACKAGE          = TrigAnalysisInterfaces
+PACKAGE_PRELOAD  =
+PACKAGE_CXXFLAGS =
+PACKAGE_LDFLAGS  =
+PACKAGE_DEP      =
+
+include $(ROOTCOREDIR)/Makefile-common

Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/requirements

+package TrigAnalysisInterfaces
+author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+
+# Gaudi/Athena package(s):
+use AtlasPolicy      AtlasPolicy-*
+use GaudiInterface   GaudiInterface-*   External
+
+# Generate Reflex dictionaries for the Athena interfaces:
+private
+use AtlasReflex     AtlasReflex-*     External -no_auto_imports
+
+apply_pattern lcgdict dict=TrigAnalysisInterfaces selectionfile=selection.xml \
+                      headerfiles="../TrigAnalysisInterfaces/TrigAnalysisInterfacesDict.h"
+
+end_private