BunchCrossingCondData Class Reference

#include <BunchCrossingCondData.h>

Collaboration diagram for BunchCrossingCondData:

Classes
struct	bunchTrain_t

Public Types
enum	BunchCrossingType {   Empty = 0 , FirstEmpty = 1 , MiddleEmpty = 2 , Single = 100 ,   Front = 200 , Middle = 201 , Tail = 202 , Unpaired = 300 }
	Enumeration type for a given bunch crossing. More...
enum	BunchDistanceType { NanoSec , BunchCrossings , FilledBunches }
	Enumeration specifying the units in which to expect the bunch distance type. More...
typedef unsigned int	bcid_type

Public Member Functions
bool	isFilled (const bcid_type bcid) const
	The simplest query: Is the bunch crossing filled or not?
bool	isInTrain (const bcid_type bcid) const
	Function deciding if a given bunch crossing is in a filled train.
bool	isUnpaired (const bcid_type bcid) const
	Function deciding if a given bunch crossing has an unpaired bunch.
bool	isBeam1 (const bcid_type bcid) const
	Function deciding if there was a bunch from "beam 1" in this bunch crossing.
bool	isBeam2 (const bcid_type bcid) const
	Function deciding if there was a bunch from "beam 2" in this bunch crossing.
BunchCrossingType	bcType (const bcid_type bcid) const
	Convenience function for the type of the specific bunch crossing.
int	gapBeforeTrain (bcid_type bcid=0, BunchDistanceType type=NanoSec) const
	Gap before the train this BCID is in.
int	gapBeforeBunch (bcid_type bcid=0, BunchDistanceType type=NanoSec) const
	Get the distance of the specified bunch crossing to the preceeding filled bunch.
int	gapAfterTrain (bcid_type bcid=0, BunchDistanceType type=NanoSec) const
	Gap after the train this BCID is in.
int	gapAfterBunch (bcid_type bcid=0, BunchDistanceType type=NanoSec) const
	Get the distance of the specified bunch crossing to the next filled bunch.
int	distanceFromFront (const bcid_type bcid, const BunchDistanceType type=NanoSec) const
	The distance of the specific bunch crossing from the front of the train.
int	distanceFromTail (const bcid_type bcid, const BunchDistanceType type=NanoSec) const
	The distance of the specific bunch crossing from the tail of the train.
unsigned int	numberOfFilledBunches () const
	Gap before the train this BCID is in.
unsigned int	numberOfUnpairedBunches () const
	Get the number of unpaired bunches in the current configuration.
unsigned int	numberOfBunchTrains () const
	Get the number of the bunch trains in the current configuration.
std::pair< unsigned, unsigned >	bunchTrainPopulation (const bcid_type bcid) const
	Get colliding and total bcids in a train.

Static Public Attributes
static constexpr int	m_MAX_BCID =3564
static constexpr int	m_BUNCH_SPACING = 25

Private Member Functions
const bunchTrain_t *	findTrain (const bcid_type bcid) const
	Helper method to find the train of a bcid (nullptr if bcd is not in a train)
unsigned	countColliding (int from, int to) const
	Helper method to count colliding bunches in the range from-to.

Private Attributes
std::bitset< m_MAX_BCID >	m_beam1
std::bitset< m_MAX_BCID >	m_beam2
std::bitset< m_MAX_BCID >	m_luminous
std::vector< bunchTrain_t >	m_trains
unsigned	m_nTrains {}

Static Private Attributes
static const int	m_headTailLength = 300

Friends
class	BunchCrossingCondAlg

Detailed Description

Definition at line 23 of file BunchCrossingCondData.h.

Member Typedef Documentation

bcid_type

typedef unsigned int BunchCrossingCondData::bcid_type

Definition at line 27 of file BunchCrossingCondData.h.

Member Enumeration Documentation

BunchCrossingType

enum BunchCrossingCondData::BunchCrossingType

Enumeration 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.

Enumerator
Empty	An empty bunch far away from filled bunches.
FirstEmpty	The first empty bunch after a train.
MiddleEmpty	An empty BCID in the middle of a train.
Single	This is a filled, single bunch (not in a train)
Front	The BCID belongs to the first few bunches in a train.
Middle	The BCID belongs to the middle bunches in a train.
Tail	The BCID belongs to the last few bunces in a train.
Unpaired	This is an unpaired bunch (either beam1 or beam2)

Definition at line 100 of file BunchCrossingCondData.h.

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

BunchDistanceType

enum BunchCrossingCondData::BunchDistanceType

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.

Enumerator
NanoSec	Distance in nanoseconds.
BunchCrossings	Distance in units of 25 nanoseconds.
FilledBunches	Distance in units of filled bunches (depends on filling scheme)

Definition at line 130 of file BunchCrossingCondData.h.

                         {
    NanoSec, 
    BunchCrossings, 
    FilledBunches
  };

Member Function Documentation

bcType()

BunchCrossingCondData::BunchCrossingType BunchCrossingCondData::bcType

(

const bcid_type

bcid

)

const

Convenience function for the type of the specific bunch crossing.

This function could be used as a single entry point to this data 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.

Parameters

bcid	The bcid that should be checked

Returns

The type of the bcid in question

Definition at line 198 of file BunchCrossingCondData.cxx.

                                                                                                {
  // First the obvious check:
  if (!isFilled(bcid))
  {
    // Check if it's an unpaired bunch:
    if (isUnpaired(bcid))
    {
      return Unpaired;
    }
    // If the previous bunch crossing is the tail of a bunch train:
    if (!distanceFromTail(bcid - 1, BunchCrossings))
    {
      return FirstEmpty;
    }
    // Check if it's in the middle of a bunch train:
    if (findTrain(bcid) != nullptr) {
      return MiddleEmpty;
    }
    // If none of the above are true, it has to be a "simple" empty bunch:
    return Empty;
  }
 
  // Now we know that the bunch has to be a filled one...
 
  // If it's not in a train, it has to be a single filled bunch:
  if (!isInTrain(bcid))
    return Single;
 
  // Let's check if it is close to the front of a bunch train:
  int distance = distanceFromFront(bcid, NanoSec);
  if ((distance >= 0) && (distance <= m_headTailLength))
  {
    return Front;
  }
  // Now let's check if it's close to the tail of a bunch train:
  distance = distanceFromTail(bcid, NanoSec);
  if ((distance >= 0) && (distance <= m_headTailLength))
  {
    return Tail;
  }
 
  // If none of the above are true, it has to be in the middle of a train:
  return Middle;
}

bunchTrainPopulation()

std::pair< unsigned, unsigned > BunchCrossingCondData::bunchTrainPopulation

(

const bcid_type

bcid

)

const

Get colliding and total bcids in a train.

This function gives the number of colliding bunches and the total number of bcids in a given train

Parameters

bcid	The bcid whose train should be investigated

Returns

a pair<colliding,total> bcids in this train

Definition at line 93 of file BunchCrossingCondData.cxx.

                                                                                                 {
 
  const bunchTrain_t* bt=findTrain(bcid);
  if (!bt) {
    return std::pair<unsigned,unsigned>(0,0);
  }
  else {
    return std::pair<unsigned,unsigned>(bt->m_nColl,(bt->m_last-bt->m_first));
  }
}

countColliding()

unsigned BunchCrossingCondData::countColliding ( int from, int to ) const

private

Helper method to count colliding bunches in the range from-to.

Definition at line 105 of file BunchCrossingCondData.cxx.

                                                                     {
  unsigned ncoll=0;
 
  if (from<0) {
    //wrap-around ...
    for (int idx=m_MAX_BCID+from;idx<m_MAX_BCID;++idx) {
      if (m_luminous.test(idx)) ++ncoll;      
    }
    from=0;
  }
 
  if (to>m_MAX_BCID) {
    for (int idx=0;idx<to-m_MAX_BCID;++idx) {
      if (m_luminous.test(idx)) ++ncoll;
    }
    to=m_MAX_BCID;
  }
     
  for (int idx=from;idx<to;++idx) {
    if (m_luminous.test(idx)) ++ncoll;      
  }
  return ncoll;
}

distanceFromFront()

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

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.

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

The distance of the bcid in question from the front of its bunch train

Definition at line 38 of file BunchCrossingCondData.cxx.

                                                               {
 
  const bunchTrain_t* bt=findTrain(bcid);
  if (!bt) {
    return -1;
  }
 
  const int dist=bcid-bt->m_first;
 
  switch( type ) {
  case NanoSec:
    return dist*m_BUNCH_SPACING;
    break;
  case BunchCrossings:
    return dist;
  case FilledBunches:
    return countColliding(bt->m_first,bt->m_last);
  default:
    MsgStream msg(Athena::getMessageSvc(),"BunchCrossingCondData::distanceFromFront");
    msg << MSG::ERROR << "BunchDistanceType not understood!" << endmsg;
    return -1;
  }//end switch
}

distanceFromTail()

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

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.

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

The distance of the bcid in question from the tail of its bunch train

Definition at line 63 of file BunchCrossingCondData.cxx.

                                                               {
 
  const bunchTrain_t* bt=findTrain(bcid);
  if (!bt) {
    return -1;
  }
 
  const int dist=bt->m_last-bcid;
 
  switch( type ) {
  case NanoSec:
    return dist*m_BUNCH_SPACING;
    break;
  case BunchCrossings:
    return dist;
  case FilledBunches:
    return countColliding(bt->m_first,bt->m_last);
  default:
    MsgStream msg(Athena::getMessageSvc(),"BunchCrossingCondData::distanceFromTail");
    msg << MSG::ERROR << "BunchDistanceType not understood!" << endmsg;
    return -1;
  }//end switch
}

findTrain()

const BunchCrossingCondData::bunchTrain_t * BunchCrossingCondData::findTrain ( const bcid_type bcid ) const

private

Helper method to find the train of a bcid (nullptr if bcd is not in a train)

Definition at line 8 of file BunchCrossingCondData.cxx.

                                                                                                    {
 
  const int bcidi=static_cast<int>(bcid);
  const auto it=std::find_if(m_trains.begin(),m_trains.end(),[&bcidi](const bunchTrain_t& bt){return (bt.m_first<=bcidi && bt.m_last>=bcidi);});
  
  if (it==m_trains.end()) {
    return nullptr;
  }
  else {
    return &(*it);
  }
 
  /*
  auto& it=std::lower_bound(m_trains.begin(),m_trains.end(),bunchTrain_t(bcid,0,0));
  if (it==m_trains.end() || it==m_trains.begin()) return nullptr;
 
  //it points now tho the train that starts after the bcid we are looking for
  //if the bcid is in a train, it must be the train before. 
  it--;
  if (it->m_first>=bcid && it->m_last<=bcid) {
    return &(*it);
  }
  else {
    return nullptr;
  }
  */
 
 
}

gapAfterBunch()

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

Get the distance of the specified bunch crossing to the next filled bunch.

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.

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

The gap after the train of the specified bcid

Definition at line 176 of file BunchCrossingCondData.cxx.

                                                    {
  int index=bcid+1;
  if (index>=m_MAX_BCID) {
    index=0;
  }
  int result=0;
  while (!m_luminous.test(index) && result<m_MAX_BCID) {
    result++;
    index++;
    if (index>=m_MAX_BCID) {
      index=0;
    }
  }
 
 if (type==NanoSec) {
    result*=m_BUNCH_SPACING;
  }
 
 return result;
}

gapAfterTrain()

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

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.)

Parameters

bcid	The bcid whose train should be investigated
type	The type of the requested return value

Returns

The gap after the train of the specified bcid

Definition at line 167 of file BunchCrossingCondData.cxx.

                                                    {
  const bunchTrain_t* bt=findTrain(bcid);
  if (bt==nullptr) {
    return -1;
  }
  return gapAfterBunch(bt->m_last,type);
}

gapBeforeBunch()

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

Get the distance of the specified bunch crossing to the preceeding filled bunch.

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.

Parameters

bcid	The bcid that should be checked
type	The type of the requested return value

Returns

Distance of the bcid to the preceeding filled bunch

Definition at line 141 of file BunchCrossingCondData.cxx.

                                                     {
  int index=bcid-1;
  if (index<0) {
    index=m_MAX_BCID-1;
  }
 
  int result=0;
  
  while (!m_luminous.test(index) && result<m_MAX_BCID) {
    result++;
    index--;
    if (index<0) {
      index=m_MAX_BCID-1;
    }
  }
 
  if (type==NanoSec) {
    result*=m_BUNCH_SPACING;
  }
 
  return result;
}

gapBeforeTrain()

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

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.)

Parameters

bcid	The bcid whose train should be investigated
type	The type of the requested return value

Returns

The gap before the train of the specified bcid

Definition at line 130 of file BunchCrossingCondData.cxx.

                                                     {
 
  const bunchTrain_t* bt=findTrain(bcid);
  if (bt==nullptr) {
    return -1;
  }
 
  return gapBeforeBunch(bt->m_first,type);
}

isBeam1()

bool BunchCrossingCondData::isBeam1 ( const bcid_type bcid ) const

inline

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.

Parameters

bcid	The bcid that should be checked

Returns

true if the bcid contained a bunch from beam 1, false otherwise

Definition at line 345 of file BunchCrossingCondData.h.

                                                               {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return m_beam1.test(bcid);
}

isBeam2()

bool BunchCrossingCondData::isBeam2 ( const bcid_type bcid ) const

inline

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.

Parameters

bcid	The bcid that should be checked

Returns

true if the bcid contained a bunch from beam 2, false otherwise

Definition at line 351 of file BunchCrossingCondData.h.

                                                              {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return  m_beam2.test(bcid);
}

isFilled()

bool BunchCrossingCondData::isFilled ( const bcid_type bcid ) const

inline

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.

Parameters

bcid	The bcid that should be checked

Returns

true if the bcid was a collision bunch crossing, false otherwise

Definition at line 339 of file BunchCrossingCondData.h.

                                                               {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return m_luminous.test(bcid);
}

isInTrain()

bool BunchCrossingCondData::isInTrain ( const bcid_type bcid ) const

inline

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.

Parameters

bcid	The bcid that should be checked

Returns

true if the bcid is part of a bunch train, false otherwise

Definition at line 376 of file BunchCrossingCondData.h.

                                                                 {
  return (findTrain(bcid) != nullptr);
}

isUnpaired()

bool BunchCrossingCondData::isUnpaired ( const bcid_type bcid ) const

inline

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 gapBeforeBunch function to decide how isolated an unpaired bunch is.

Parameters

bcid	The bcid that should be checked

Returns

true if the bcid belongs to an unpaired bunch, false otherwise

Definition at line 358 of file BunchCrossingCondData.h.

                                                                  {
  if (ATH_UNLIKELY(bcid>=m_MAX_BCID)) return false;
  return ((m_beam1.test(bcid) || m_beam2.test(bcid)) && !m_luminous.test(bcid)); 
 
}

numberOfBunchTrains()

unsigned int BunchCrossingCondData::numberOfBunchTrains ( ) const

inline

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

Definition at line 371 of file BunchCrossingCondData.h.

                                                              {
  return m_trains.size();
}

numberOfFilledBunches()

unsigned BunchCrossingCondData::numberOfFilledBunches ( ) const

inline

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.)

Parameters

bcid	The bcid whose train should be investigated
type	The type of the requested return value

Returns

The gap before the train of the specified bcid

Definition at line 365 of file BunchCrossingCondData.h.

                                                            {
  return m_luminous.count();
}

numberOfUnpairedBunches()

unsigned BunchCrossingCondData::numberOfUnpairedBunches

(

)

const

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

Definition at line 88 of file BunchCrossingCondData.cxx.

                                                              {
  return ((m_beam1 | m_beam2) & ~m_luminous).count();
}

Friends And Related Symbol Documentation

BunchCrossingCondAlg

friend class BunchCrossingCondAlg

friend

Definition at line 306 of file BunchCrossingCondData.h.

Member Data Documentation

m_beam1

std::bitset<m_MAX_BCID> BunchCrossingCondData::m_beam1

private

Definition at line 310 of file BunchCrossingCondData.h.

m_beam2

std::bitset<m_MAX_BCID> BunchCrossingCondData::m_beam2

private

Definition at line 311 of file BunchCrossingCondData.h.

m_BUNCH_SPACING

int BunchCrossingCondData::m_BUNCH_SPACING = 25

staticconstexpr

Definition at line 29 of file BunchCrossingCondData.h.

m_headTailLength

const int BunchCrossingCondData::m_headTailLength = 300

staticprivate

Definition at line 313 of file BunchCrossingCondData.h.

m_luminous

std::bitset<m_MAX_BCID> BunchCrossingCondData::m_luminous

private

Definition at line 312 of file BunchCrossingCondData.h.

m_MAX_BCID

int BunchCrossingCondData::m_MAX_BCID =3564

staticconstexpr

Definition at line 28 of file BunchCrossingCondData.h.

m_nTrains

unsigned BunchCrossingCondData::m_nTrains {}

private

Definition at line 325 of file BunchCrossingCondData.h.

{}; //might be one less than the size of m_trains

m_trains

std::vector<bunchTrain_t> BunchCrossingCondData::m_trains

private

Definition at line 323 of file BunchCrossingCondData.h.

---

The documentation for this class was generated from the following files:

• BunchCrossingCondData.h
• BunchCrossingCondData.cxx