/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/TrigBunchCrossingTool/TrigBunchCrossingTool/BunchCrossingToolBase.h

// Dear emacs, this is -*- c++ -*-
// $Id: BunchCrossingToolBase.h 618331 2014-09-24 11:55:26Z krasznaa $
#ifndef TRIGBUNCHCROSSINGTOOL_BUNCHCROSSINGTOOLBASE_H
#define TRIGBUNCHCROSSINGTOOL_BUNCHCROSSINGTOOLBASE_H

// STL include(s):
#include <set>
#include <vector>
#include <string>

// Gaudi/Athena include(s):
#include "AsgTools/AsgMetadataTool.h"

// Interface include(s):
#include "TrigAnalysisInterfaces/IBunchCrossingTool.h"

// Local include(s):
#include "TrigBunchCrossingTool/BunchCrossing.h"
#include "TrigBunchCrossingTool/BunchTrain.h"

namespace Trig {

   class BunchCrossingToolBase : public virtual IBunchCrossingTool,
                                 public asg::AsgMetadataTool {

   public:
      BunchCrossingToolBase( const std::string& name = "BunchCrossingToolBase" );


      virtual bool isFilled( bcid_type bcid ) const;

      virtual bool isInTrain( bcid_type bcid ) const;

      virtual bool isUnpaired( bcid_type bcid ) const;

      virtual bool isBeam1( bcid_type bcid ) const;

      virtual bool isBeam2( bcid_type bcid ) const;

      virtual float bcIntensity( bcid_type bcid,
                                 BeamType type = Crossing ) const;

      virtual BunchCrossingType bcType( bcid_type bcid ) const;

      virtual int distanceFromFront( bcid_type bcid,
                                     BunchDistanceType type = NanoSec ) const;
      virtual int distanceFromTail( bcid_type bcid,
                                    BunchDistanceType type = NanoSec ) const;

      virtual int gapBeforeTrain( bcid_type bcid,
                                  BunchDistanceType type = NanoSec ) const;
      virtual int gapAfterTrain( bcid_type bcid,
                                 BunchDistanceType type = NanoSec ) const;

      virtual int gapBeforeBunch( bcid_type bcid,
                                  BunchDistanceType dtype = NanoSec,
                                  BunchFillType ftype = CollidingBunch ) const;
      virtual int gapAfterBunch( bcid_type bcid,
                                 BunchDistanceType dtype = NanoSec,
                                 BunchFillType ftype = CollidingBunch ) const;

      virtual std::vector< bool > bunchesInFront( bcid_type bcid,
                                                  int bunches = 10 ) const;
      virtual std::vector< bool > bunchesAfter( bcid_type bcid = 0,
                                                int bunches = 10 ) const;

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

      virtual unsigned int numberOfFilledBunches() const;
      virtual unsigned int numberOfUnpairedBunches() const;
      virtual unsigned int numberOfBunchTrains() const;
      virtual int bunchTrainSpacing( BunchDistanceType type = NanoSec ) const;


   protected:
      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 >() );
      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 >() );
      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 >() );

      void printConfig() const;


      std::set< Trig::BunchCrossing > m_filledBunches;
      std::set< Trig::BunchCrossing > m_singleBunches;
      std::set< Trig::BunchCrossing > m_unpairedBunches;
      std::set< Trig::BunchTrain > m_bunchTrains;



      int m_maxBunchSpacing;
      int m_frontLength;
      int m_tailLength;


   }; // class BunchCrossingToolBase

} // namespace Trig

#endif // TRIGBUNCHCROSSINGTOOL_BUNCHCROSSINGTOOLBASE_H

---