BunchCrossing.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: BunchCrossing.cxx 618129 2014-09-23 11:37:00Z krasznaa $
 
// System include(s):
#include <iostream>
 
// Gaudi/Athena include(s):
#include "AsgMessaging/AsgMessaging.h"
 
// Local include(s):
#include "TrigBunchCrossingTool/BunchCrossing.h"
 
namespace Trig {
 
   //
   // Initialize the static variables:
   //
   const int BunchCrossing::MAX_BCID = 3564;
   const int BunchCrossing::BUNCH_SPACING = 25;
 
   BunchCrossing::BunchCrossing( int bcid, float intBeam1, float intBeam2 )
      : 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::BunchCrossing( unsigned int bcid, float intBeam1,
                                 float intBeam2 )
      : 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::BunchCrossing( const BunchCrossing& parent )
      : m_bcid( parent.m_bcid ), m_intensityBeam1( parent.m_intensityBeam1 ),
        m_intensityBeam2( parent.m_intensityBeam2 ) {
 
   }
 
   BunchCrossing& BunchCrossing::operator=( const BunchCrossing& parent ) {
 
      // 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;
   }
 
   BunchCrossing::operator int&() {
 
      return m_bcid;
   }
 
   BunchCrossing::operator const int&() const {
 
      return m_bcid;
   }
 
   BunchCrossing& BunchCrossing::operator+= ( const BunchCrossing& bc ) {
 
      m_bcid += bc.m_bcid;
      while( m_bcid >= MAX_BCID ) {
         m_bcid -= MAX_BCID;
      }
 
      return *this;
   }
 
   BunchCrossing& BunchCrossing::operator-= ( const BunchCrossing& bc ) {
 
      m_bcid -= bc.m_bcid;
      if( m_bcid < 0 ) {
         m_bcid = MAX_BCID + m_bcid;
      }
 
      return *this;
   }
 
   BunchCrossing& BunchCrossing::operator++ () {
 
      return operator+=( 1 );
   }
 
   BunchCrossing BunchCrossing::operator++ ( int ) {
 
      BunchCrossing result = *this;
      operator+=( 1 );
      return result;
   }
 
   BunchCrossing& BunchCrossing::operator-- () {
 
      return operator-=( 1 );
   }
 
   BunchCrossing BunchCrossing::operator-- ( int ) {
 
      BunchCrossing result = *this;
      operator-=( 1 );
      return result;
   }
 
   int BunchCrossing::distance( const BunchCrossing& bc ) const {
 
      BunchCrossing ibc = *this - bc;
      if( ibc.m_bcid > ( MAX_BCID / 2 ) ) {
         return ( MAX_BCID - ibc.m_bcid );
      } else {
         return ibc.m_bcid;
      }
   }
 
   int BunchCrossing::gapFrom( const BunchCrossing& bc ) const {
 
      return ( *this - bc );
   }
 
   int BunchCrossing::gapTo( const BunchCrossing& bc ) const {
 
      return ( bc - *this );
   }
 
   int BunchCrossing::bcid() const {
 
      return m_bcid;
   }
 
   void BunchCrossing::setBCID( int bcid ) {
 
      m_bcid = bcid;
      return;
   }
 
   float BunchCrossing::intensityBeam1() const {
 
      return m_intensityBeam1;
   }
 
   void BunchCrossing::setIntensityBeam1( float intensity ) {
 
      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;
   }
 
   float BunchCrossing::intensityBeam2() const {
 
      return m_intensityBeam2;
   }
 
   void BunchCrossing::setIntensityBeam2( float intensity ) {
 
      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;
   }
 
   bool BunchCrossing::operator== ( const BunchCrossing& bc ) const {
 
      return ( m_bcid == bc.m_bcid );
   }
 
   BunchCrossing operator+ ( const BunchCrossing& bc1, const BunchCrossing& bc2 ) {
 
      BunchCrossing result( bc1 );
      result += bc2;
 
      return result;
   }
 
   BunchCrossing operator- ( const BunchCrossing& bc1, const BunchCrossing& bc2 ) {
 
      BunchCrossing result( bc1 );
      result -= bc2;
 
      return result;
   }
 
   int distance( const BunchCrossing bc1, const BunchCrossing bc2 ) {
 
      return bc1.distance( bc2 );
   }
 
} // namespace Trig
 
std::ostream& operator<< ( std::ostream& out, const Trig::BunchCrossing& bc ) {
 
   out << "[id:" << bc.bcid() << ";int1:" << bc.intensityBeam1()
       << ";int2:" << bc.intensityBeam2() << "]";
 
   return out;
}
 
MsgStream& operator<< ( MsgStream& out, const Trig::BunchCrossing& bc ) {
 
   out << "[id:" << bc.bcid() << ";int1:" << bc.intensityBeam1()
       << ";int2:" << bc.intensityBeam2() << "]";
 
   return out;
}