BunchCrossingToolBase.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#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;
 
 
   private:
      int bunchSpacing( const std::vector< int >& bunches ) const;
 
   }; // class BunchCrossingToolBase
 
} // namespace Trig
 
#endif // TRIGBUNCHCROSSINGTOOL_BUNCHCROSSINGTOOLBASE_H