BunchCrossingCondData.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#ifndef LUMIBLOCKDATA_BUNCHCROSSINGCONDDATA_H
#define LUMIBLOCKDATA_BUNCHCROSSINGCONDDATA_H
 
 
#include "AthenaKernel/CondCont.h"
#include "AthenaKernel/CLASS_DEF.h"
#include <vector>
#include <bitset>
 
 
class BunchCrossingCondData {
 
public:
 
  typedef unsigned int bcid_type;
  static constexpr int m_MAX_BCID=3564;
  static constexpr int m_BUNCH_SPACING = 25;
 


  bool isFilled(const bcid_type bcid ) const;
    


  bool isInTrain(const bcid_type bcid ) const;


  bool isUnpaired(const bcid_type bcid ) const;


  bool isBeam1(const bcid_type bcid ) const;


  bool isBeam2(const bcid_type bcid ) const;


  enum BunchCrossingType
  {
    Empty = 0,       
    FirstEmpty = 1,  
    MiddleEmpty = 2, 
    Single = 100,    
    Front = 200,     
    Middle = 201,    
    Tail = 202,      
    Unpaired = 300   
  };


  BunchCrossingType bcType(const bcid_type bcid ) const;


  enum BunchDistanceType {
    NanoSec, 
    BunchCrossings, 
    FilledBunches
  };


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

  int gapBeforeBunch( bcid_type bcid = 0,
              BunchDistanceType type = NanoSec ) const;
  


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

 
  int gapAfterBunch( bcid_type bcid = 0,
             BunchDistanceType type = NanoSec ) const;
 


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


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


 
  unsigned int numberOfFilledBunches() const;


  unsigned int numberOfUnpairedBunches() const;
  

  unsigned int numberOfBunchTrains() const;
 


  std::pair<unsigned,unsigned> bunchTrainPopulation(const bcid_type bcid) const;
 
 
private:
 
  friend class BunchCrossingCondAlg;// The cond-alg filling this class
 
 
  // Data
  std::bitset<m_MAX_BCID> m_beam1;
  std::bitset<m_MAX_BCID> m_beam2;
  std::bitset<m_MAX_BCID> m_luminous;
  const static int m_headTailLength = 300; // magic number 300 ns from Run 2 tool
 
  struct bunchTrain_t {
    bunchTrain_t(bcid_type first, bcid_type last, unsigned ncoll) : 
      m_first(first),m_last(last),m_nColl(ncoll) {};
    int m_first{};      
    int m_last{};       
    unsigned m_nColl{}; 
  };
 
  std::vector<bunchTrain_t> m_trains;
 
  unsigned m_nTrains{}; //might be one less than the size of m_trains

  const bunchTrain_t* findTrain(const bcid_type bcid) const;

  unsigned countColliding(int from, int to) const;
 
};  
 
CLASS_DEF (BunchCrossingCondData, 158463439, 0)
CONDCONT_MIXED_DEF (BunchCrossingCondData, 157905099 );
 
inline 
bool BunchCrossingCondData::isFilled(const bcid_type bcid) const {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return m_luminous.test(bcid);
}
 
inline
bool  BunchCrossingCondData::isBeam1(const bcid_type bcid) const {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return m_beam1.test(bcid);
}
 
inline
bool BunchCrossingCondData::isBeam2(const bcid_type bcid) const {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return  m_beam2.test(bcid);
}
 
 
inline 
bool  BunchCrossingCondData::isUnpaired(const bcid_type bcid) const {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return ((m_beam1.test(bcid) || m_beam2.test(bcid)) && !m_luminous.test(bcid)); 
 
}
 
inline 
unsigned BunchCrossingCondData::numberOfFilledBunches() const {
  return m_luminous.count();
}
 
 
inline 
unsigned int BunchCrossingCondData::numberOfBunchTrains() const {
  return m_trains.size();
}
 
inline 
bool BunchCrossingCondData::isInTrain(const bcid_type bcid ) const {
  return (findTrain(bcid) != nullptr);
}
 
#endif // not COOLLUMIUTILITIES_FILLPARAMSCONDDATA_H