LHCInfo.cc

Go to the documentation of this file.

#include "CondFormats/RunInfo/interface/LHCInfo.h"
#include "CondFormats/Common/interface/TimeConversions.h"
#include <algorithm>
#include <iterator>
#include <vector>
#include <stdexcept>

//helper function: returns the positions of the bits in the bitset that are set (i.e., have a value of 1).
static std::vector<unsigned short> bitsetToVector( std::bitset<LHCInfo::bunchSlots+1> const & bs ) {
  std::vector<unsigned short> vec;
  //reserve space only for the bits in the bitset that are set
  vec.reserve( bs.count() );
  for( size_t i = 0; i < bs.size(); ++i ) {
    if( bs.test( i ) )
      vec.push_back( (unsigned short) i );
  }
  return vec;
}

//helper function: returns the enum for fill types in string type
static std::string fillTypeToString( LHCInfo::FillTypeId const & fillType ) {
  std::string s_fillType( "UNKNOWN" );
  switch( fillType ) {
  case LHCInfo::UNKNOWN :
    s_fillType = std::string( "UNKNOWN" );
    break;
  case LHCInfo::PROTONS :
    s_fillType = std::string( "PROTONS" );
    break;
  case LHCInfo::IONS :
    s_fillType = std::string( "IONS" );
    break;
  case LHCInfo::COSMICS :
    s_fillType = std::string( "COSMICS" );
    break;
  case LHCInfo::GAP :
    s_fillType = std::string( "GAP" );
    break;
  default :
    s_fillType = std::string( "UNKNOWN" );
  }
  return s_fillType;
}

//helper function: returns the enum for particle types in string type
static std::string particleTypeToString( LHCInfo::ParticleTypeId const & particleType ) {
  std::string s_particleType( "NONE" );
  switch( particleType ) {
  case LHCInfo::NONE :
    s_particleType = std::string( "NONE" );
    break;
  case LHCInfo::PROTON :
    s_particleType = std::string( "PROTON" );
    break;
  case LHCInfo::PB82 :
    s_particleType = std::string( "PB82" );
    break;
  case LHCInfo::AR18 :
    s_particleType = std::string( "AR18" );
    break;
  case LHCInfo::D :
    s_particleType = std::string( "D" );
    break;
  case LHCInfo::XE54 :
    s_particleType = std::string( "XE54" );
    break;
  default :
    s_particleType = std::string( "NONE" );
  }
  return s_particleType;
}

LHCInfo::LHCInfo(){
  m_intParams.resize( ISIZE, std::vector<unsigned int>(1,0) );
  m_floatParams.resize( FSIZE, std::vector<float>(1, 0.) );
  m_floatParams[ LUMI_PER_B ] = std::vector<float>();
  m_floatParams[ BEAM1_VC ] = std::vector<float>();
  m_floatParams[ BEAM2_VC ] = std::vector<float>();
  m_floatParams[ BEAM1_RF ] = std::vector<float>();
  m_floatParams[ BEAM2_RF ] = std::vector<float>();
  m_timeParams.resize( TSIZE, std::vector<unsigned long long>(1,0ULL) );
  m_stringParams.resize( SSIZE, std::vector<std::string>(1, "") );
  m_stringParams[ INJECTION_SCHEME ].push_back( std::string("None") );
}

LHCInfo::LHCInfo( const LHCInfo& rhs ):
  m_intParams( rhs.m_intParams ),
  m_floatParams( rhs.m_floatParams ),
  m_timeParams( rhs.m_timeParams ),
  m_stringParams( rhs.m_stringParams ),
  m_bunchConfiguration1( rhs.m_bunchConfiguration1), 
  m_bunchConfiguration2( rhs.m_bunchConfiguration2){
}

LHCInfo::~LHCInfo() {
}

LHCInfo* LHCInfo::cloneFill() const {
  LHCInfo* ret = new LHCInfo();
  ret->m_isData = m_isData;
  if( !m_intParams[0].empty()){
    for(size_t i=0;i<LUMI_SECTION; i++) ret->m_intParams[i]=m_intParams[i];
    for(size_t i=0;i<DELIV_LUMI; i++) ret->m_floatParams[i]=m_floatParams[i];
    ret->m_floatParams[LUMI_PER_B] = m_floatParams[LUMI_PER_B];
    for(size_t i=0;i<TSIZE; i++) ret->m_timeParams[i]=m_timeParams[i];
    for(size_t i=0;i<LHC_STATE; i++) ret->m_stringParams[i]=m_stringParams[i];
    ret->m_bunchConfiguration1=m_bunchConfiguration1;
    ret->m_bunchConfiguration2=m_bunchConfiguration2;
  }
  return ret;
}

namespace LHCInfoImpl {
  template <typename T> const T& getParams( const std::vector<T>& params, size_t index ){
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    return params[index];
  }  

  template <typename T> T& accessParams( std::vector<T>& params, size_t index ){
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    return params[index];
  }

  template <typename T> const T& getOneParam( const std::vector< std::vector<T> >& params, size_t index ){
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    const std::vector<T>& inner = params[index];
    if( inner.empty() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" type="+typeid(T).name()+" has no value stored.");
    return inner[ 0 ];
  }

  template <typename T> void setOneParam( std::vector< std::vector<T> >& params, size_t index, const T& value ){
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    params[ index ] = std::vector<T>(1,value);
  }

  template <typename T> void setParams( std::vector<T>& params, size_t index, const T& value ){
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    params[ index ] = value;
  }

}

//getters
unsigned short const LHCInfo::fillNumber() const {
  return LHCInfoImpl::getOneParam( m_intParams, LHC_FILL );
}

unsigned short const LHCInfo::bunchesInBeam1() const {
  return LHCInfoImpl::getOneParam( m_intParams, BUNCHES_1 );
}

unsigned short const LHCInfo::bunchesInBeam2() const {
  return LHCInfoImpl::getOneParam( m_intParams, BUNCHES_2 );
}

unsigned short const LHCInfo::collidingBunches() const {
  return LHCInfoImpl::getOneParam( m_intParams, COLLIDING_BUNCHES );
}

unsigned short const LHCInfo::targetBunches() const {
  return LHCInfoImpl::getOneParam( m_intParams, TARGET_BUNCHES );
}

LHCInfo::FillTypeId const LHCInfo::fillType() const {
  return static_cast<FillTypeId>(LHCInfoImpl::getOneParam( m_intParams, FILL_TYPE ));
}

LHCInfo::ParticleTypeId const LHCInfo::particleTypeForBeam1() const {
  return static_cast<ParticleTypeId>(LHCInfoImpl::getOneParam( m_intParams, PARTICLES_1 ));
}

LHCInfo::ParticleTypeId const LHCInfo::particleTypeForBeam2() const {
  return static_cast<ParticleTypeId>(LHCInfoImpl::getOneParam( m_intParams, PARTICLES_2 ));
}

float const LHCInfo::crossingAngle() const {
  return LHCInfoImpl::getOneParam( m_floatParams, CROSSING_ANGLE );
}

float const LHCInfo::betaStar() const {
  return LHCInfoImpl::getOneParam( m_floatParams, BETA_STAR );
}

float const LHCInfo::intensityForBeam1() const {
  return LHCInfoImpl::getOneParam( m_floatParams, INTENSITY_1 );
}

float const LHCInfo::intensityForBeam2() const {
  return LHCInfoImpl::getOneParam( m_floatParams, INTENSITY_2 );
}

float const LHCInfo::energy() const {
  return LHCInfoImpl::getOneParam( m_floatParams, ENERGY );
}

float const LHCInfo::delivLumi() const {
  return LHCInfoImpl::getOneParam( m_floatParams, DELIV_LUMI );
}

float const LHCInfo::recLumi() const {
  return LHCInfoImpl::getOneParam( m_floatParams, REC_LUMI );
}

float const LHCInfo::instLumi() const {
  return LHCInfoImpl::getOneParam( m_floatParams, INST_LUMI );
}

float const LHCInfo::instLumiError() const {
  return LHCInfoImpl::getOneParam( m_floatParams, INST_LUMI_ERR );
}

cond::Time_t const LHCInfo::createTime() const {
  return LHCInfoImpl::getOneParam( m_timeParams, CREATE_TIME );
}

cond::Time_t const LHCInfo::beginTime() const {
  return LHCInfoImpl::getOneParam(m_timeParams, BEGIN_TIME );
}

cond::Time_t const LHCInfo::endTime() const {
  return LHCInfoImpl::getOneParam(m_timeParams, END_TIME );
}

std::string const & LHCInfo::injectionScheme() const {
  return LHCInfoImpl::getOneParam(m_stringParams, INJECTION_SCHEME );
}

std::vector<float> const & LHCInfo::lumiPerBX() const {
  return LHCInfoImpl::getParams(m_floatParams, LUMI_PER_B );
}

std::string const & LHCInfo::lhcState() const {
  return LHCInfoImpl::getOneParam(m_stringParams, LHC_STATE );
}

std::string const & LHCInfo::lhcComment() const {
  return LHCInfoImpl::getOneParam(m_stringParams, LHC_COMMENT );
}

std::string const & LHCInfo::ctppsStatus() const {
  return LHCInfoImpl::getOneParam(m_stringParams, CTPPS_STATUS );
}

unsigned int const & LHCInfo::lumiSection() const {
  return LHCInfoImpl::getOneParam(m_intParams, LUMI_SECTION );
}

std::vector<float> const & LHCInfo::beam1VC() const {
  return LHCInfoImpl::getParams(m_floatParams, BEAM1_VC );
}

std::vector<float> const & LHCInfo::beam2VC() const {
  return LHCInfoImpl::getParams(m_floatParams, BEAM2_VC );
}

std::vector<float> const & LHCInfo::beam1RF() const {
  return LHCInfoImpl::getParams(m_floatParams, BEAM1_RF );
}

std::vector<float> const & LHCInfo::beam2RF() const {
  return LHCInfoImpl::getParams(m_floatParams, BEAM2_RF );
}

std::vector<float>& LHCInfo::beam1VC(){
  return LHCInfoImpl::accessParams(m_floatParams, BEAM1_VC );
}

std::vector<float>& LHCInfo::beam2VC(){
  return LHCInfoImpl::accessParams(m_floatParams, BEAM2_VC );
}

std::vector<float>& LHCInfo::beam1RF(){
  return LHCInfoImpl::accessParams(m_floatParams, BEAM1_RF );
}

std::vector<float>& LHCInfo::beam2RF(){
  return LHCInfoImpl::accessParams(m_floatParams, BEAM2_RF );
}

//returns a boolean, true if the injection scheme has a leading 25ns
//TODO: parse the circulating bunch configuration, instead of the string.
bool LHCInfo::is25nsBunchSpacing() const {
  const std::string prefix( "25ns" );
  return std::equal( prefix.begin(), prefix.end(), injectionScheme().begin() );
}

//returns a boolean, true if the bunch slot number is in the circulating bunch configuration
bool LHCInfo::isBunchInBeam1( size_t const & bunch ) const {
  if( bunch == 0 )
    throw std::out_of_range( "0 not allowed" ); //CMS starts counting bunch crossing from 1!
  return m_bunchConfiguration1.test( bunch );
}

bool LHCInfo::isBunchInBeam2( size_t const & bunch ) const {
  if( bunch == 0 )
    throw std::out_of_range( "0 not allowed" ); //CMS starts counting bunch crossing from 1!
  return m_bunchConfiguration2.test( bunch );
}

//member functions returning *by value* a vector with all filled bunch slots
std::vector<unsigned short> LHCInfo::bunchConfigurationForBeam1() const {
  return bitsetToVector( m_bunchConfiguration1 );
}

std::vector<unsigned short> LHCInfo::bunchConfigurationForBeam2() const {
  return bitsetToVector( m_bunchConfiguration2 );
}

void LHCInfo::setFillNumber( unsigned short lhcFill ) {
  LHCInfoImpl::setOneParam( m_intParams, LHC_FILL, static_cast<unsigned int>(lhcFill) );
}

//setters
void LHCInfo::setBunchesInBeam1( unsigned short const & bunches ) {
  LHCInfoImpl::setOneParam( m_intParams, BUNCHES_1, static_cast<unsigned int>(bunches) );
}

void LHCInfo::setBunchesInBeam2( unsigned short const & bunches ) {
  LHCInfoImpl::setOneParam( m_intParams, BUNCHES_2, static_cast<unsigned int>(bunches) );
}

void LHCInfo::setCollidingBunches( unsigned short const & collidingBunches ) {
  LHCInfoImpl::setOneParam( m_intParams, COLLIDING_BUNCHES, static_cast<unsigned int>(collidingBunches) );
}

void LHCInfo::setTargetBunches( unsigned short const & targetBunches ) {
  LHCInfoImpl::setOneParam( m_intParams, TARGET_BUNCHES, static_cast<unsigned int>(targetBunches) );  
}

void LHCInfo::setFillType( LHCInfo::FillTypeId const & fillType ) {
  LHCInfoImpl::setOneParam( m_intParams, FILL_TYPE, static_cast<unsigned int>(fillType) );
}

void LHCInfo::setParticleTypeForBeam1( LHCInfo::ParticleTypeId const & particleType ) {
  LHCInfoImpl::setOneParam( m_intParams, PARTICLES_1, static_cast<unsigned int>(particleType) );
}

void LHCInfo::setParticleTypeForBeam2( LHCInfo::ParticleTypeId const & particleType ) {
  LHCInfoImpl::setOneParam( m_intParams, PARTICLES_2, static_cast<unsigned int>(particleType) );
}

void LHCInfo::setCrossingAngle( float const & angle ) {
  LHCInfoImpl::setOneParam( m_floatParams, CROSSING_ANGLE, angle );
}
  
void LHCInfo::setBetaStar( float const & betaStar ) {
  LHCInfoImpl::setOneParam( m_floatParams, BETA_STAR, betaStar );
}

void LHCInfo::setIntensityForBeam1( float const & intensity ) {
  LHCInfoImpl::setOneParam( m_floatParams, INTENSITY_1, intensity );
}

void LHCInfo::setIntensityForBeam2( float const & intensity ) {
  LHCInfoImpl::setOneParam( m_floatParams, INTENSITY_2, intensity );
}

void LHCInfo::setEnergy( float const & energy ) {
  LHCInfoImpl::setOneParam( m_floatParams, ENERGY, energy );
}

void LHCInfo::setDelivLumi( float const & delivLumi ) {
  LHCInfoImpl::setOneParam( m_floatParams, DELIV_LUMI, delivLumi );
}

void LHCInfo::setRecLumi( float const & recLumi ) {
  LHCInfoImpl::setOneParam( m_floatParams, REC_LUMI, recLumi );
}

void LHCInfo::setInstLumi( float const & instLumi ) {
  LHCInfoImpl::setOneParam( m_floatParams, INST_LUMI, instLumi );
}

void LHCInfo::setInstLumiError( float const & instLumiError ) {
  LHCInfoImpl::setOneParam( m_floatParams, INST_LUMI_ERR, instLumiError );
}

void LHCInfo::setCreationTime( cond::Time_t const & createTime ) {
  LHCInfoImpl::setOneParam( m_timeParams, CREATE_TIME, createTime );
}

void LHCInfo::setBeginTime( cond::Time_t const & beginTime ) {
  LHCInfoImpl::setOneParam( m_timeParams, BEGIN_TIME, beginTime );
}

void LHCInfo::setEndTime( cond::Time_t const & endTime ) {
  LHCInfoImpl::setOneParam( m_timeParams, END_TIME, endTime );
}

void LHCInfo::setInjectionScheme( std::string const & injectionScheme ) {
  LHCInfoImpl::setOneParam( m_stringParams, INJECTION_SCHEME, injectionScheme );
}

void LHCInfo::setLumiPerBX( std::vector<float> const & lumiPerBX) {
  LHCInfoImpl::setParams( m_floatParams, LUMI_PER_B, lumiPerBX );
}

void LHCInfo::setLhcState( std::string const & lhcState) {
  LHCInfoImpl::setOneParam( m_stringParams, LHC_STATE, lhcState );
}

void LHCInfo::setLhcComment( std::string const & lhcComment) {
  LHCInfoImpl::setOneParam( m_stringParams, LHC_COMMENT, lhcComment );
}

void LHCInfo::setCtppsStatus( std::string const & ctppsStatus) {
  LHCInfoImpl::setOneParam( m_stringParams, CTPPS_STATUS, ctppsStatus );
}

void LHCInfo::setLumiSection( unsigned int const & lumiSection) {
  LHCInfoImpl::setOneParam( m_intParams, LUMI_SECTION, lumiSection );
}

void LHCInfo::setBeam1VC( std::vector<float> const & beam1VC) {
  LHCInfoImpl::setParams( m_floatParams, BEAM1_VC, beam1VC );
}

void LHCInfo::setBeam2VC( std::vector<float> const & beam2VC) {
  LHCInfoImpl::setParams( m_floatParams, BEAM2_VC, beam2VC );
}

void LHCInfo::setBeam1RF( std::vector<float> const & beam1RF) {
  LHCInfoImpl::setParams( m_floatParams, BEAM1_RF, beam1RF );
}

void LHCInfo::setBeam2RF( std::vector<float> const & beam2RF) {
  LHCInfoImpl::setParams( m_floatParams, BEAM2_RF, beam2RF );
}

//sets all values in one go
void LHCInfo::setInfo( unsigned short const & bunches1
                ,unsigned short const & bunches2
                ,unsigned short const & collidingBunches
                ,unsigned short const & targetBunches
                ,FillTypeId const & fillType
                ,ParticleTypeId const & particleType1
                ,ParticleTypeId const & particleType2
                ,float const & angle
                ,float const & beta
                ,float const & intensity1
                ,float const & intensity2
                ,float const & energy
                ,float const & delivLumi
                ,float const & recLumi
                    ,float const & instLumi
                    ,float const & instLumiError
                ,cond::Time_t const & createTime
                ,cond::Time_t const & beginTime
                ,cond::Time_t const & endTime
                ,std::string const & scheme
                ,std::vector<float> const & lumiPerBX
                ,std::string const & lhcState
                ,std::string const & lhcComment
                ,std::string const & ctppsStatus
                ,unsigned int const & lumiSection
                ,std::vector<float> const & beam1VC
                ,std::vector<float> const & beam2VC
                ,std::vector<float> const & beam1RF
                ,std::vector<float> const & beam2RF
                ,std::bitset<bunchSlots+1> const & bunchConf1
                ,std::bitset<bunchSlots+1> const & bunchConf2 ) {
  this->setBunchesInBeam1( bunches1 );
  this->setBunchesInBeam2( bunches2 );
  this->setCollidingBunches( collidingBunches );
  this->setTargetBunches( targetBunches );
  this->setFillType( fillType );
  this->setParticleTypeForBeam1( particleType1 );
  this->setParticleTypeForBeam2( particleType2 );
  this->setCrossingAngle( angle );
  this->setBetaStar( beta );
  this->setIntensityForBeam1( intensity1 );
  this->setIntensityForBeam2( intensity2 );
  this->setEnergy( energy );
  this->setDelivLumi( delivLumi );
  this->setRecLumi( recLumi );
  this->setInstLumi( instLumi );
  this->setInstLumiError( instLumiError );
  this->setCreationTime( createTime );
  this->setBeginTime( beginTime );
  this->setEndTime( endTime );
  this->setInjectionScheme( scheme );
  this->setLumiPerBX( lumiPerBX );
  this->setLhcState( lhcState );
  this->setLhcComment( lhcComment );
  this->setCtppsStatus( ctppsStatus );
  this->setLumiSection( lumiSection );
  this->setBeam1VC( beam1VC );
  this->setBeam2VC( beam2VC );
  this->setBeam1RF( beam1RF );
  this->setBeam2RF( beam2RF );
  this->setBunchBitsetForBeam1( bunchConf1 );
  this->setBunchBitsetForBeam2( bunchConf2 );
}

void LHCInfo::print( std::stringstream & ss ) const {
  ss << "LHC fill: " << this->fillNumber() << std::endl
     << "Bunches in Beam 1: " << this->bunchesInBeam1() << std::endl
     << "Bunches in Beam 2: " << this->bunchesInBeam2() << std::endl
     << "Colliding bunches at IP5: " << this->collidingBunches() << std::endl
     << "Target bunches at IP5: " <<this->targetBunches() << std::endl
     << "Fill type: " << fillTypeToString( static_cast<FillTypeId> (this->fillType() ) ) << std::endl
     << "Particle type for Beam 1: " << particleTypeToString( static_cast<ParticleTypeId>( this->particleTypeForBeam1() ) ) << std::endl
     << "Particle type for Beam 2: " << particleTypeToString( static_cast<ParticleTypeId>( this->particleTypeForBeam2() ) ) << std::endl
     << "Crossing angle (urad): " << this->crossingAngle() << std::endl
     << "Beta star (cm): " << this->betaStar() << std::endl
     << "Average Intensity for Beam 1 (number of charges): " << this->intensityForBeam1() << std::endl
     << "Average Intensity for Beam 2 (number of charges): " << this->intensityForBeam2() << std::endl
     << "Energy (GeV): " << this->energy() << std::endl
     << "Delivered Luminosity (max): " << this->delivLumi() << std::endl
     << "Recorded Luminosity (max): " << this->recLumi() << std::endl
     << "Instantaneous Luminosity: " << this->instLumi() << std::endl
     << "Instantaneous Luminosity Error: " << this->instLumiError() << std::endl
     << "Creation time of the fill: " << boost::posix_time::to_iso_extended_string( cond::time::to_boost( this->createTime() ) ) << std::endl
     << "Begin time of Stable Beam flag: " << boost::posix_time::to_iso_extended_string( cond::time::to_boost( this->beginTime() ) ) << std::endl
     << "End time of the fill: " << boost::posix_time::to_iso_extended_string( cond::time::to_boost( this->endTime() ) ) << std::endl
     << "Injection scheme as given by LPC: " << this->injectionScheme() << std::endl
     << "LHC State: " << this->lhcState() << std::endl
     << "LHC Comments: " << this->lhcComment() << std::endl
     << "CTPPS Status: " << this->ctppsStatus() << std::endl
     << "Lumi section: " << this->lumiSection() << std::endl;
     
  ss << "Luminosity per bunch  (total " << this->lumiPerBX().size() << "): ";
  std::copy( this->lumiPerBX().begin(), this->lumiPerBX().end(), std::ostream_iterator<float>( ss, ", " ) );
  ss << std::endl;
    
  ss << "Beam 1 VC  (total " << this->beam1VC().size() << "): ";
  std::copy( this->beam1VC().begin(), this->beam1VC().end(), std::ostream_iterator<float>( ss, "\t" ) );
  ss << std::endl;
  
  ss << "Beam 2 VC  (total " << beam2VC().size() << "): ";
  std::copy( beam2VC().begin(), beam2VC().end(), std::ostream_iterator<float>( ss, "\t" ) );
  ss << std::endl;
  
  ss << "Beam 1 RF  (total " << beam1RF().size() << "): ";
  std::copy( beam1RF().begin(), beam1RF().end(), std::ostream_iterator<float>( ss, "\t" ) );
  ss << std::endl;
  
  ss << "Beam 2 RF  (total " << beam2RF().size() << "): ";
  std::copy( beam2RF().begin(), beam2RF().end(), std::ostream_iterator<float>( ss, "\t" ) );
  ss << std::endl;
  
  std::vector<unsigned short> bunchVector1 = this->bunchConfigurationForBeam1();
  std::vector<unsigned short> bunchVector2 = this->bunchConfigurationForBeam2();
  ss << "Bunches filled for Beam 1 (total " << bunchVector1.size() << "): ";
  std::copy( bunchVector1.begin(), bunchVector1.end(), std::ostream_iterator<unsigned short>( ss, ", " ) );
  ss << std::endl;
  ss << "Bunches filled for Beam 2 (total " << bunchVector2.size() << "): ";
  std::copy( bunchVector2.begin(), bunchVector2.end(), std::ostream_iterator<unsigned short>( ss, ", " ) );
  ss << std::endl;
}

//protected getters
std::bitset<LHCInfo::bunchSlots+1> const & LHCInfo::bunchBitsetForBeam1() const {
  return m_bunchConfiguration1;  
}

std::bitset<LHCInfo::bunchSlots+1> const & LHCInfo::bunchBitsetForBeam2() const {
  return m_bunchConfiguration2;  
}

//protected setters
void LHCInfo::setBunchBitsetForBeam1( std::bitset<LHCInfo::bunchSlots+1> const & bunchConfiguration ) {
  m_bunchConfiguration1 = bunchConfiguration;
}

void LHCInfo::setBunchBitsetForBeam2( std::bitset<LHCInfo::bunchSlots+1> const & bunchConfiguration ) {
  m_bunchConfiguration2 = bunchConfiguration;
}

std::ostream & operator<<( std::ostream & os, LHCInfo beamInfo ) {
  std::stringstream ss;
  beamInfo.print( ss );
  os << ss.str();
  return os;
}

bool LHCInfo::equals( const LHCInfo& rhs ) const {
  if( m_isData != rhs.m_isData ) return false;
  if( m_intParams != rhs.m_intParams  ) return false;
  if( m_floatParams != rhs.m_floatParams  ) return false;
  if( m_timeParams != rhs.m_timeParams  ) return false;
  if( m_stringParams != rhs.m_stringParams  ) return false;
  if( m_bunchConfiguration1 != rhs.m_bunchConfiguration1 ) return false;
  if( m_bunchConfiguration2 != rhs.m_bunchConfiguration2 ) return false;
  return true;
}

bool LHCInfo::empty() const {
  return m_intParams[0].empty();
}