A smart integer class representing bunch crossings. More...

#include <BunchCrossing.h>

Collaboration diagram for Trig::BunchCrossing:

Public Member Functions
	BunchCrossing (int bcid=0, float intBeam1=1.0, float intBeam2=1.0)
	Constructor with a value. More...

	BunchCrossing (unsigned int bcid, float intBeam1=1.0, float intBeam2=1.0)
	Constructor with an unsigned value. More...

	BunchCrossing (const BunchCrossing &parent)
	Copy constructor. More...

BunchCrossing &	operator= (const BunchCrossing &parent)
	Assignment operator. More...

	operator int & ()
	Automatic conversion operator. More...

	operator const int & () const
	Automatic conversion operator (constant version) More...

BunchCrossing &	operator+= (const BunchCrossing &bc)
	Operator adding another BunchCrossing object. More...

BunchCrossing &	operator-= (const BunchCrossing &bc)
	Operator subtracting another BunchCrossing object. More...

BunchCrossing &	operator++ ()
	Operator pushing the object to the next bunch crossing. More...

BunchCrossing	operator++ (int)
	Operator pushing the object to the next bunch crossing. More...

BunchCrossing &	operator-- ()
	Operator pushing the object to the previous bunch crossing. More...

BunchCrossing	operator-- (int)
	Operator pushing the object to the previous bunch crossing. More...

int	distance (const BunchCrossing &bc) const
	The distance from another bunch crossing. More...

int	gapFrom (const BunchCrossing &bc) const
	Distance from a previous bunch crossing. More...

int	gapTo (const BunchCrossing &bc) const
	Distance to a following bunch crossing. More...

int	bcid () const
	Get the BCID of this bunch crossing. More...

void	setBCID (int bcid)
	Set the BCID of this bunch crossing. More...

float	intensityBeam1 () const
	Get the "intensity" of beam 1 in this bunch crossing. More...

void	setIntensityBeam1 (float intensity)
	Set the "intensity" of beam 1 in this bunch crossing. More...

float	intensityBeam2 () const
	Get the "intensity" of beam 2 in this bunch crossing. More...

void	setIntensityBeam2 (float intensity)
	Set the "intensity" of beam 2 in this bunch crossing. More...

bool	operator== (const BunchCrossing &bc) const
	Equality operator for bunch crossings. More...

Static Public Attributes
static const int	BUNCH_SPACING = 25
	Minimum spacing between the bunches, in nanoseconds. More...

static const int	MAX_BCID = 3564
	The maximum number of bunches that can be in the LHC. More...

Private Attributes
int	m_bcid
	The BCID of this bunch crossing. More...

float	m_intensityBeam1
	Intensity of the bunch in "beam 1" some measure. More...

float	m_intensityBeam2
	Intensity of the bunch in "beam 2" some measure. More...

Detailed Description

A smart integer class representing bunch crossings.

   There can be a maximum of 3564 bunches in the LHC. And BCID
   #0 and #3563 are just beside each other. To have the STL
   algorithms take this into account, objects of this class
   behave as "smart" integer variables, which respect the properties
   of the LHC.

Author: Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Revision: 618129

Date: 2014-09-23 13:37:00 +0200 (Tue, 23 Sep 2014)

Definition at line 33 of file BunchCrossing.h.

Constructor & Destructor Documentation

◆ BunchCrossing() [1/3]

Trig::BunchCrossing::BunchCrossing	(	int	bcid = `0`,
		float	intBeam1 = `1.0`,
		float	intBeam2 = `1.0`
	)

Constructor with a value.

The TrigConf::BunchGroup objects store the BCIDs as signed integers, hence this constructor.

Parameters

bcid	The bunch crossing ID of the bunch crossing
intBeam1	The intensity of beam 1, or the intensity/luminosity of the crossing
intBeam2	The intensity of beam 2

Definition at line 33 of file BunchCrossing.cxx.

       : m_bcid( bcid ), m_intensityBeam1( intBeam1 ),
         m_intensityBeam2( intBeam2 ) {
  
       if( m_bcid < 0 ) {
          m_bcid = MAX_BCID + m_bcid;
       }
       while( m_bcid >= MAX_BCID ) {
          m_bcid -= MAX_BCID;
       }
    }

◆ BunchCrossing() [2/3]

Trig::BunchCrossing::BunchCrossing	(	unsigned int	bcid,
		float	intBeam1 = `1.0`,
		float	intBeam2 = `1.0`
	)

Constructor with an unsigned value.

The EventID objects store the BCIDs as unsigned integers, so this other version has to exist as well.

(In order to define clearly what the compiler should do.)

Parameters

bcid	The bunch crossing ID of the bunch crossing
intBeam1	The intensity of beam 1, or the intensity/luminosity of the crossing
intBeam2	The intensity of beam 2

Definition at line 55 of file BunchCrossing.cxx.

       : m_bcid( static_cast< int >( bcid ) ), m_intensityBeam1( intBeam1 ),
         m_intensityBeam2( intBeam2 ) {
  
       if( m_bcid < 0 ) {
          m_bcid = MAX_BCID + m_bcid;
       }
       while( m_bcid >= MAX_BCID ) {
          m_bcid -= MAX_BCID;
       }
    }

◆ BunchCrossing() [3/3]

Trig::BunchCrossing::BunchCrossing ( const BunchCrossing & parent )

Copy constructor.

The copy constructor makes sure that only important properites are copied.

The class at one point had some transient variables. But not anymore, so this constructor is pretty useless. But at least it's not harmful...

Parameters

parent The object that is to be copied

Definition at line 75 of file BunchCrossing.cxx.

       : m_bcid( parent.m_bcid ), m_intensityBeam1( parent.m_intensityBeam1 ),
         m_intensityBeam2( parent.m_intensityBeam2 ) {
  
    }

Member Function Documentation

◆ bcid()

int Trig::BunchCrossing::bcid ( ) const

Get the BCID of this bunch crossing.

Some parts of the code have to access the BCID and the bunch crossing intensity explicitly, it's just nicer (and more readable) to do it using a function than to use the dereferencing operator (*) in all those cases.

Returns: The BCID of this bunch crossing

Definition at line 267 of file BunchCrossing.cxx.

                                  {
  
       return m_bcid;
    }

◆ distance()

int Trig::BunchCrossing::distance ( const BunchCrossing & bc ) const

The distance from another bunch crossing.

Function calculating the absolute value of the distance of two bunches.

If you just use something like std::abs( b1 - b2 ), the result will depend on the order of the two bunches. Sometimes that's the expected behaviour, but for simple distance calculations this function should be used.

Parameters

bc	The other BunchCrossing

Returns: The distance of the specified bunch crossing from this one in BCIDs

Definition at line 216 of file BunchCrossing.cxx.

                                                               {
  
       BunchCrossing ibc = *this - bc;
       if( ibc.m_bcid > ( MAX_BCID / 2 ) ) {
          return ( MAX_BCID - ibc.m_bcid );
       } else {
          return ibc.m_bcid;
       }
    }

◆ gapFrom()

int Trig::BunchCrossing::gapFrom ( const BunchCrossing & bc ) const

Distance from a previous bunch crossing.

As it turns out, the distance(...) function can not be used when calculating the gaps between bunches, as the "direction" of the gap matters a lot in this case.

(So, the gap can be larger than half of the LHC ring.)

In the end, this is just a nicely named function on top of the arithmetic that was designed for this class.

Parameters

bc	The "previous" bunch to which the distance should be calculated

Returns: The gap before this bunch to the specified one in BCIDs

Definition at line 238 of file BunchCrossing.cxx.

                                                              {
  
       return ( *this - bc );
    }

◆ gapTo()

int Trig::BunchCrossing::gapTo ( const BunchCrossing & bc ) const

Distance to a following bunch crossing.

As it turns out, the distance(...) function can not be used when calculating the gaps between bunches, as the "direction" of the gap matters a lot in this case.

(So, the gap can be larger than half of the LHC ring.)

In the end, this is just a nicely named function on top of the arithmetic that was designed for this class.

Parameters

bc	The "next" bunch to which the distance should be calculated

Returns: The gap after this bunch to the specified one in BCIDs

Definition at line 255 of file BunchCrossing.cxx.

                                                            {
  
       return ( bc - *this );
    }

◆ intensityBeam1()

float Trig::BunchCrossing::intensityBeam1 ( ) const

Get the "intensity" of beam 1 in this bunch crossing.

The intensity of the beam in a bunch crossing means a bit different things for data and for MC, but in both cases it can be described by a floating point number.

Returns: The "intensity" of beam 1 in this bunch crossing

Definition at line 291 of file BunchCrossing.cxx.

                                              {
  
       return m_intensityBeam1;
    }

◆ intensityBeam2()

float Trig::BunchCrossing::intensityBeam2 ( ) const

Get the "intensity" of beam 2 in this bunch crossing.

The intensity of the beam in a bunch crossing means a bit different things for data and for MC, but in both cases it can be described by a floating point number.

Returns: The "intensity" of beam 2 in this bunch crossing

Definition at line 321 of file BunchCrossing.cxx.

                                              {
  
       return m_intensityBeam2;
    }

◆ operator const int &()

Trig::BunchCrossing::operator const int & ( ) const

Automatic conversion operator (constant version)

The automatic conversion operators are here to be able to handle bunch crossing objects like a simple integer value in the code.

This makes using the STL code much simpler in some places.

Returns: The BCID value of this object (constant version)

Definition at line 119 of file BunchCrossing.cxx.

                                             {
  
       return m_bcid;
    }

◆ operator int &()

Trig::BunchCrossing::operator int & ( )

Automatic conversion operator.

The automatic conversion operators are here to be able to handle bunch crossing objects like a simple integer value in the code.

This makes using the STL code much simpler in some places.

Returns: The BCID value of this object

Definition at line 107 of file BunchCrossing.cxx.

                                 {
  
       return m_bcid;
    }

◆ operator++() [1/2]

BunchCrossing & Trig::BunchCrossing::operator++ ( )

Operator pushing the object to the next bunch crossing.

This operator can be used when you want to iterate over bunch crossings.

It makes sure that the bunch crossings follow each other in the right order.

Returns: A reference to the incremented object

Definition at line 164 of file BunchCrossing.cxx.

                                              {
  
       return operator+=( 1 );
    }

◆ operator++() [2/2]

BunchCrossing Trig::BunchCrossing::operator++ ( int )

Operator pushing the object to the next bunch crossing.

This operator can be used when you want to iterate over bunch crossings.

It makes sure that the bunch crossings follow each other in the right order.

Returns: The object's state before the increment

Definition at line 175 of file BunchCrossing.cxx.

                                                  {
  
       BunchCrossing result = *this;
       operator+=( 1 );
       return result;
    }

◆ operator+=()

BunchCrossing & Trig::BunchCrossing::operator+= ( const BunchCrossing & bc )

Operator adding another BunchCrossing object.

This operator is overriden to take the properties of the LHC bunches into account.

Parameters

bc	The bunch crossing that should be added to this one

Returns: The updated bunch crossing object

Definition at line 131 of file BunchCrossing.cxx.

                                                                       {
  
       m_bcid += bc.m_bcid;
       while( m_bcid >= MAX_BCID ) {
          m_bcid -= MAX_BCID;
       }
  
       return *this;
    }

◆ operator--() [1/2]

BunchCrossing & Trig::BunchCrossing::operator-- ( )

Operator pushing the object to the previous bunch crossing.

This operator can be used when you want to iterate over bunch crossings.

It makes sure that the bunch crossings follow each other in the right order.

Returns: A reference to the decreased object

Definition at line 188 of file BunchCrossing.cxx.

                                              {
  
       return operator-=( 1 );
    }

◆ operator--() [2/2]

BunchCrossing Trig::BunchCrossing::operator-- ( int )

Operator pushing the object to the previous bunch crossing.

This operator can be used when you want to iterate over bunch crossings.

It makes sure that the bunch crossings follow each other in the right order.

Returns: The object's state before the decrease

Definition at line 199 of file BunchCrossing.cxx.

                                                  {
  
       BunchCrossing result = *this;
       operator-=( 1 );
       return result;
    }

◆ operator-=()

BunchCrossing & Trig::BunchCrossing::operator-= ( const BunchCrossing & bc )

Operator subtracting another BunchCrossing object.

This operator is overriden to take the properties of the LHC bunches into account.

Parameters

bc	The bunch crossing that should be subtracted from this one

Returns: The updated bunch crossing object

Definition at line 148 of file BunchCrossing.cxx.

                                                                       {
  
       m_bcid -= bc.m_bcid;
       if( m_bcid < 0 ) {
          m_bcid = MAX_BCID + m_bcid;
       }
  
       return *this;
    }

◆ operator=()

BunchCrossing & Trig::BunchCrossing::operator= ( const BunchCrossing & parent )

Assignment operator.

Just like the copy constructor, this operator isn't strictly speaking needed either.

But if I left the copy constructor in, I should have this here as well.

Parameters

parent The object whose properties are to be copied

Definition at line 88 of file BunchCrossing.cxx.

                                                                         {
  
       // Check that it's not a self-assignment:
       if( &parent == this ) return *this;
  
       m_bcid = parent.m_bcid;
       m_intensityBeam1 = parent.m_intensityBeam1;
       m_intensityBeam2 = parent.m_intensityBeam2;
  
       return *this;
    }

◆ operator==()

bool Trig::BunchCrossing::operator== ( const BunchCrossing & bc ) const

Equality operator for bunch crossings.

The compiler would probably be able to do this same thing automatically thanks to the automatic conversion operators, but I wanted to be sure.

The equality of two BunchCrossing objects should not depend on the intensity stored in them, only the BCIDs that they describe.

Parameters

bc	The bunch crossing object that this object should be compared to

Returns: true if the BCID of the two objects is the same, false otherwise

Definition at line 354 of file BunchCrossing.cxx.

                                                                   {
  
       return ( m_bcid == bc.m_bcid );
    }

◆ setBCID()

void Trig::BunchCrossing::setBCID ( int bcid )

Set the BCID of this bunch crossing.

This function is not used anywhere in the code I think, but for completeness's sake it makes sense to have it here.

Parameters

bcid	The BCID that this object should describe

Definition at line 278 of file BunchCrossing.cxx.

                                          {
  
       m_bcid = bcid;
       return;
    }

◆ setIntensityBeam1()

void Trig::BunchCrossing::setIntensityBeam1 ( float intensity )

Set the "intensity" of beam 1 in this bunch crossing.

See also: BunchCrossing::intensity()

Parameters

intensity The value that the beam 1 intensity should be set to

Definition at line 300 of file BunchCrossing.cxx.

                                                           {
  
       if( intensity >= 0.0 ) {
          m_intensityBeam1 = intensity;
       } else {
          asg::AsgMessaging logger( "Trig::BunchCrossing" );
          logger.msg() << MSG::ERROR
                       << "Trying to set beam 1 intensity to negative number ("
                       << intensity << "). Using 0.0 instead." << endmsg;
          m_intensityBeam1 = 0.0;
       }
       return;
    }

◆ setIntensityBeam2()

void Trig::BunchCrossing::setIntensityBeam2 ( float intensity )

Set the "intensity" of beam 2 in this bunch crossing.

See also: BunchCrossing::intensity()

Parameters

intensity The value that the beam 2 intensity should be set to

Definition at line 330 of file BunchCrossing.cxx.

                                                           {
  
       if( intensity >= 0.0 ) {
          m_intensityBeam2 = intensity;
       } else {
          asg::AsgMessaging logger( "Trig::BunchCrossing" );
          logger.msg() << MSG::ERROR
                       << "Trying to set beam 2 intensity to negative number ("
                       << intensity << "). Using 0.0 instead." << endmsg;
          m_intensityBeam2 = 0.0;
       }
       return;
    }

Member Data Documentation

◆ BUNCH_SPACING

const int Trig::BunchCrossing::BUNCH_SPACING = 25

static

Minimum spacing between the bunches, in nanoseconds.

Definition at line 48 of file BunchCrossing.h.

◆ m_bcid

int Trig::BunchCrossing::m_bcid

private

The BCID of this bunch crossing.

Definition at line 98 of file BunchCrossing.h.

◆ m_intensityBeam1

float Trig::BunchCrossing::m_intensityBeam1

private

Intensity of the bunch in "beam 1" some measure.

Definition at line 100 of file BunchCrossing.h.

◆ m_intensityBeam2

float Trig::BunchCrossing::m_intensityBeam2

private

Intensity of the bunch in "beam 2" some measure.

Definition at line 102 of file BunchCrossing.h.

◆ MAX_BCID

const int Trig::BunchCrossing::MAX_BCID = 3564

static

The maximum number of bunches that can be in the LHC.

Definition at line 50 of file BunchCrossing.h.

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

Public Member Functions

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BunchCrossing() [1/3]

◆ BunchCrossing() [2/3]

◆ BunchCrossing() [3/3]

Member Function Documentation

◆ bcid()

◆ distance()

◆ gapFrom()

◆ gapTo()

◆ intensityBeam1()

◆ intensityBeam2()

◆ operator const int &()

◆ operator int &()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=()

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator-=()

◆ operator=()

◆ operator==()

◆ setBCID()

◆ setIntensityBeam1()

◆ setIntensityBeam2()

Member Data Documentation

◆ BUNCH_SPACING

◆ m_bcid

◆ m_intensityBeam1

◆ m_intensityBeam2

◆ MAX_BCID