BunchTrain.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
// System include(s):
#include <cstdlib>
#include <iostream>
 
// Gaudi/Athena include(s):
#include "AsgMessaging/AsgMessaging.h"
 
// Local include(s):
#include "TrigBunchCrossingTool/BunchTrain.h"
#include "SetPrint.h"
 
namespace Trig {

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

   BunchTrain::BunchTrain( const BunchTrain& parent )
      : std::set< BunchCrossing >( parent ), m_spacing( -1 ),
        m_front(), m_back(), m_gapFound( false ) {
 
      validate();
   }
 
   BunchTrain& BunchTrain::operator= ( const BunchTrain& rhs ) {
 
      // 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;
   }

   int BunchTrain::spacing() const {
 
      return m_spacing;
   }

   int BunchTrain::distance( const BunchCrossing& bc ) const {
 
      // 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;
   }

   bool BunchTrain::isInside( const BunchCrossing& bc ) const {
 
      // 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;
   }

   BunchTrain::const_iterator BunchTrain::train_front() const {
 
      if( m_gapFound ) {
         return m_front;
      } else {
         return begin();
      }
   }

   BunchTrain::const_iterator BunchTrain::train_back() const {
 
      if( m_gapFound ) {
         return m_back;
      } else {
         return ( --end() );
      }
   }

   bool BunchTrain::validate() {

      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;
   }

   bool operator< ( const BunchTrain& bt1, const BunchTrain& bt2 ) {
 
      if( ! bt2.size() ) return false;
      if( ! bt1.size() ) return true;
 
      return ( ( *bt1.begin() ) < ( *bt2.begin() ) );
   }
 
} // namespace Trig

std::ostream& operator<< ( std::ostream& stream, const Trig::BunchTrain& bt ) {
 
   // Take advantage of the output operator defined for std::set objects:
   stream << "[spacing: " << bt.spacing() << "; bunches: "
          << static_cast< const std::set< Trig::BunchCrossing >& >( bt )
          << "; front: " << *bt.train_front() << "; back: "
          << *bt.train_back() << "]";
 
   return stream;
}

MsgStream& operator<< ( MsgStream& stream, const Trig::BunchTrain& bt ) {
 
   // Take advantage of the output operator defined for std::set objects:
   stream << "[spacing: " << bt.spacing() << "; bunches: "
          << static_cast< const std::set< Trig::BunchCrossing >& >( bt )
          << "; front: " << *bt.train_front() << "; back: "
          << *bt.train_back() << "]";
 
   return stream;
}