Trig::BunchTrain Class Reference

A smart set of BunchCrossing objects. More...

#include <BunchTrain.h>

Inheritance diagram for Trig::BunchTrain:

Collaboration diagram for Trig::BunchTrain:

Public Member Functions
	BunchTrain ()
	Default constructor. More...
	BunchTrain (const BunchTrain &parent)
	Copy constructor. More...
BunchTrain &	operator= (const BunchTrain &rhs)
	Assignment operator. More...
int	spacing () const
	Spacing of the bunches in this train in nanoseconds. More...
int	distance (const BunchCrossing &bc) const
	"Distance" of a bunch crossing from this bunch train More...
bool	isInside (const BunchCrossing &bc) const
	Check if a bunch crossing is inside this train. More...
const_iterator	train_front () const
	Iterator pointing to the first bunch in the train. More...
const_iterator	train_back () const
	Iterator pointing to the last bunch in the train. More...
bool	validate ()
	Check the spacing of the bunches in the train. More...

Public Attributes
K	keys
	STL member. More...

Private Attributes
int	m_spacing
	Spacing of the bunches in nanoseconds. More...
const_iterator	m_front
	Iterator pointing to the first bunch. More...
const_iterator	m_back
	Iterator pointing to the last bunch. More...
bool	m_gapFound
	Flag specifying if the train spreads over the "BCID turnover". More...

Detailed Description

A smart set of BunchCrossing objects.

   This class is used internally to describe a bunch train. It's basically
   just a list of BunchCrossing objects with a couple of convenience
   functions.

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 35 of file BunchTrain.h.

Constructor & Destructor Documentation

BunchTrain() [1/2]

Trig::BunchTrain::BunchTrain

(

)

Default constructor.

Default constructor, creating an empty bunch train.

Definition at line 22 of file BunchTrain.cxx.

      : std::set< BunchCrossing >(), m_spacing( -1 ),
        m_front(), m_back(), m_gapFound( false ) {
 
   }

BunchTrain() [2/2]

Trig::BunchTrain::BunchTrain

(

const BunchTrain &

parent

)

Copy constructor.

The internal iterators don't remain valid if we just use the default copy constructor.

Hence when the object is copied, the validation has to be run again.

Parameters

parent

The original BunchTrain object

Definition at line 35 of file BunchTrain.cxx.

      : std::set< BunchCrossing >( parent ), m_spacing( -1 ),
        m_front(), m_back(), m_gapFound( false ) {
 
      validate();
   }

Member Function Documentation

distance()

int Trig::BunchTrain::distance

(

const BunchCrossing &

bc

)

const

"Distance" of a bunch crossing from this bunch train

This function is used by the code to determine if a new bunch crossing should be merged into this bunch train or not.

The calculation of the distance of a bunch crossing from a bunch train is pretty simple. If the train is empty, or the bunch crossing is already in it, the distance is 0. Otherwise the code calculates the distance of the reference bunch crossing from all the bunch crossings which are already in the train, and takes the smallest value. It's not the fastest method, but it's the only reliable method that I've found...

Parameters

bc	The reference bunch crossing

Returns

The distance of the reference bunch crossing from this bunch train

Definition at line 92 of file BunchTrain.cxx.

                                                           {
 
      // If the train is empty, by definition the distance is 0:
      if( ! size() ) return 0;
 
      // If the BC is already in the train, it has a distance of 0 from it:
      if( find( bc ) != end() ) return 0;
 
      // Calculate the BC's distance from all the bunches in the train, and take the
      // smallest one:
      int min_distance = BunchCrossing::MAX_BCID;
      BunchTrain::const_iterator itr = begin();
      for( ; itr != end(); ++itr ) {
         int diff;
         if( ( diff = itr->distance( bc ) ) < min_distance ) {
            min_distance = diff;
         }
      }
 
      return min_distance;
   }

isInside()

bool Trig::BunchTrain::isInside

(

const BunchCrossing &

bc

)

const

Check if a bunch crossing is inside this train.

This function checks if the specified bunch crossing is "inside" this bunch train.

This can mean two different things. Either the bunch crossing is a filled bunch crossing which is part of the train, or the bunch crossing is an empty bunch crossing which is between the front and the tail of this train.

Parameters

bc	The reference bunch crossing

Returns

true if the reference bunch crossing is "inside" the train, or false if it isn't

Definition at line 125 of file BunchTrain.cxx.

                                                            {
 
      // If it's a filled bunch crossing in this train, then it's inside of it:
      if( find( bc ) != end() ) return true;
 
      // Check if the bunch crossing is an empty bunch crossing inside
      // this train:
      if( m_gapFound ) {
         if( ( ( *begin() < bc ) && ( *train_back() > bc ) ) ||
             ( ( *train_front() < bc ) && ( *( --end() ) > bc ) ) ) {
            return true;
         }
      } else {
         if( ( *train_front() < bc ) && ( *train_back() > bc ) ) {
            return true;
         }
      }
 
      // If none of the above are true, then the reference is not inside
      // of this train:
      return false;
   }

operator=()

BunchTrain & Trig::BunchTrain::operator=

(

const BunchTrain &

rhs

)

Assignment operator.

Definition at line 42 of file BunchTrain.cxx.

                                                             {
 
      // Protect against self-assignment:
      if( this == &rhs ) {
         return *this;
      }
 
      // Do the heavy lifting in the base class's assignment operator:
      std::set< BunchCrossing >::operator=( rhs );
 
      // Reset the cached variables:
      m_front = end();
      m_back  = end();
      m_gapFound = false;
 
      // Cache the variables:
      validate();
 
      // Return the updated object:
      return *this;
   }

spacing()

int Trig::BunchTrain::spacing

(

)

const

Spacing of the bunches in this train in nanoseconds.

The spacing between the bunches in the train is calculated by the BunchTrain::validate() function, so you should only trust this value once the validation ran on this object.

The value is stored in nanoseconds to maybe make the meaning of the value a bit more obvious.

Returns

The bunch spacing in nanoseconds, or -1 if the object has not been validated yet

Definition at line 75 of file BunchTrain.cxx.

                                 {
 
      return m_spacing;
   }

train_back()

BunchTrain::const_iterator Trig::BunchTrain::train_back

(

)

const

Iterator pointing to the last bunch in the train.

The returned iterator always points to the last bunch of the train.

Note that it is a valid iterator, which actually points to the end of the train. So you shouldn't use it in for loops like end().

The rest of the logic is the same as with train_front().

See also

train_front

Returns

The element that is logically at the back of the train

Definition at line 185 of file BunchTrain.cxx.

                                                         {
 
      if( m_gapFound ) {
         return m_back;
      } else {
         return ( --end() );
      }
   }

train_front()

BunchTrain::const_iterator Trig::BunchTrain::train_front

(

)

const

Iterator pointing to the first bunch in the train.

The returned iterator always points to the first bunch of the train.

Note however, that can only be "logically" the first bunch of the train. When a train stretches over the "BCID turnover" region, the underlying std::set object will order the bunches like this:

0, 1, 2, 3562, 3563

In this case 3562 is the first bunch of the train, and this function will return an iterator pointing to that element.

This iterator is determined in the validate() function, so the code must always call validate() at least once before using this iterator.

Returns

The element that is logically the front of the train

Definition at line 165 of file BunchTrain.cxx.

                                                          {
 
      if( m_gapFound ) {
         return m_front;
      } else {
         return begin();
      }
   }

validate()

bool Trig::BunchTrain::validate

(

)

Check the spacing of the bunches in the train.

The function checks if the bunches in the train have equal spacing in between them.

This should be the case if everything went correctly with the code...

It also checks whether the train stretches over the "BCID turnover" or not. If it does, it sets the m_front and m_back variables correctly. If it does not, then the train doesn't have to be treated in a special way.

Returns

true if the validation passes, false otherwise

Helper object to print logging messages:

Definition at line 205 of file BunchTrain.cxx.

                             {
 
      static const asg::AsgMessaging logger( "Trig::BunchTrain" );
 
      // Reset the gap flag:
      m_gapFound = false;
 
      // Loop over all the bunch crossings of this train:
      BunchTrain::const_iterator itr = begin();
      size_t bunch_pos = 0;
      BunchTrain::const_iterator next;
      for( ; itr != end(); ++itr, ++bunch_pos ) {
         // Set up an iterator to the next bunch crossing in the train:
         next = itr; ++next;
         if( next == end() ) continue;
         // Calculate the spacing between these two:
         int diff = BunchCrossing::BUNCH_SPACING * next->distance( *itr );
         if( m_spacing < 0 ) { // If these are the first two bunches of the train
            m_spacing = diff;
         }
         // Check if it is the same as the stored value:
         else if( diff != m_spacing ) {
            // If not, there can be a two valid reasons for it. First is that we've been seeing
            // the correct bunch spacing so far, and we just reached the gap:
            if( ( ! m_gapFound ) && ( diff > m_spacing ) ) {
               m_gapFound = true;
               m_front = next;
               m_back  = itr;
            }
            // Or that the spacing between the first two bunches was actually the gap,
            // and not the train's bunch spacing. (For trains like: [0, 3561, 3562, 3563])
            else if( ( bunch_pos == 1 ) && ( ! m_gapFound ) && ( diff < m_spacing ) ) {
               m_gapFound = true;
               m_front = itr;
               m_back = itr; --m_back;
               m_spacing = diff;
            }
            // Or finally it could be that the configuration is just weird...
            else {
               logger.msg() << MSG::WARNING << "Bunches don't appear to have "
                            << "equal spacing!" << endmsg;
               return false;
            }
         }
      }
 
      // Report what we found out about this train:
      if( m_gapFound ) {
         logger.msg() << MSG::VERBOSE
                      << "Gap found in train! train_front = "
                      << *train_front() << "; train_back = "
                      << *train_back() << endmsg;
      } else {
         logger.msg() << MSG::VERBOSE
                      << "Gap not found in train! train_front = "
                      << *train_front() << "; train_back = "
                      << *train_back() << endmsg;
      }
 
      return true;
   }

Member Data Documentation

keys

K std::set< K >::keys

inherited

STL member.

m_back

const_iterator Trig::BunchTrain::m_back

private

Iterator pointing to the last bunch.

Definition at line 64 of file BunchTrain.h.

m_front

const_iterator Trig::BunchTrain::m_front

private

Iterator pointing to the first bunch.

Definition at line 63 of file BunchTrain.h.

m_gapFound

bool Trig::BunchTrain::m_gapFound

private

Flag specifying if the train spreads over the "BCID turnover".

Definition at line 65 of file BunchTrain.h.

m_spacing

int Trig::BunchTrain::m_spacing

private

Spacing of the bunches in nanoseconds.

Definition at line 62 of file BunchTrain.h.

---

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

• BunchTrain.h
• BunchTrain.cxx