diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/Root/LinkDef.h b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/Root/LinkDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c47ee3a822663523d7fc158016c937fd45c451c
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/Root/LinkDef.h
@@ -0,0 +1,25 @@
+// 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__
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingConfProvider.h b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingConfProvider.h
new file mode 100644
index 0000000000000000000000000000000000000000..20213ae1cadac07a03fe9f3b8a0d09a1b5d91a57
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingConfProvider.h
@@ -0,0 +1,165 @@
+// 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
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingTool.h b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..df30f63fc6dd390ddf4a9d26ae35a51b33c58de6
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IBunchCrossingTool.h
@@ -0,0 +1,56 @@
+// 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
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IIBunchCrossingTool.h b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IIBunchCrossingTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..11cf482f2db49f92f4d3610b1a79af334828677f
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/IIBunchCrossingTool.h
@@ -0,0 +1,410 @@
+// 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
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/TrigAnalysisInterfacesDict.h b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/TrigAnalysisInterfacesDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..c53602d333ec8ec346f155835b5d2244df264828
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/TrigAnalysisInterfacesDict.h
@@ -0,0 +1,17 @@
+// 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
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/selection.xml b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..bbb2a393f5be5dca46f9d03d4debcf10bcf5e3ea
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/TrigAnalysisInterfaces/selection.xml
@@ -0,0 +1,9 @@
+<!-- $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>
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/Makefile.RootCore b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/Makefile.RootCore
new file mode 100644
index 0000000000000000000000000000000000000000..5d5d3875706626e16b17de587ce05b979b99cfee
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/Makefile.RootCore
@@ -0,0 +1,11 @@
+# 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
diff --git a/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/requirements b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/requirements
new file mode 100644
index 0000000000000000000000000000000000000000..aa2c0e53ca150a04d433adbca09e88ca12176bfd
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigAnalysisInterfaces/cmt/requirements
@@ -0,0 +1,15 @@
+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