MuonDQAEventInfo.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// Package : MuonDQAMonitoring                                          // 
// Class to store event information in for MuonDQAMonitoring            //
// based on MuonCalibAlgs                                               //
// Author: N. Benekos - UIUC                                            //
// Date  : March 2008                                                   //
 
 
#ifndef MuonDQAEventInfo_h
#define MuonDQAEventInfo_h
 
#include <string>
#include <iosfwd>
#include <vector>
#include <bitset>
 
namespace MuonDQA {
  class MuonDQAEventInfo{
  public:
    MuonDQAEventInfo(); 
   
    MuonDQAEventInfo( unsigned int run_number, unsigned int event_number ); 
    
    MuonDQAEventInfo( unsigned int run_number, unsigned int event_number, unsigned int time_stamp ); 
    
    MuonDQAEventInfo( unsigned int run_number, unsigned int event_number, unsigned int time_stamp , unsigned int lumi_block  ); 
              
    MuonDQAEventInfo( unsigned int run_number,        // Run Number
                      unsigned int event_number,      // Event Number
              unsigned int time_stamp,        // Time stamp
                      unsigned int ns_Offset,         // ns Offset            
              const std::bitset<8> & trig_Type,        // Trigger Type
              float running_time,             // Running Time 
              unsigned int lumi_block,         // Lumi Block  
             
              std::string tag ); 
 
    MuonDQAEventInfo( const MuonDQAEventInfo& eventInfo ); 
    ~MuonDQAEventInfo(); 
    
    std::ostream& dump( std::ostream& stream ) const ;
    
    unsigned int runNumber()   const { return m_runNumber ; }   
    unsigned int eventNumber() const { return m_eventNumber ; } 
    unsigned int timeStamp()   const { return m_timeStamp ; }   
    unsigned int ns_Offset()   const { return m_ns_Offset ; }   
    const std::bitset<8> trigType()  const { return m_trigType ; }    
    float runningtime() const { return m_running_time; } 
    unsigned int lumiBlock()   const { return m_lumiBlock ; }    
    
   
    std::string  tag() const { return m_tag ; } 
    const std::vector<bool> & triggerBits() const {return m_trigger_bits;}
 
    void setRunNumber( const unsigned int run_number ) { m_runNumber = run_number ; } 
    void setEventNumber( const unsigned int event_number ) { m_eventNumber = event_number ; } 
    void setTimeStamp( const unsigned int time_stamp ) { m_timeStamp = time_stamp ; } 
    void setOffset( const unsigned int ns_Offset ) { m_ns_Offset = ns_Offset ; } 
    void setTrigType( const std::bitset<8> & trig_Type ) { m_trigType = trig_Type ; } 
    void setRunTime( const float running_time ) { m_running_time = running_time ; } 
    void setLumiBlock( const unsigned int lumi_block ) { m_lumiBlock = lumi_block ; } 
   
    void setTag( const std::string & tag ) { m_tag = tag ; } 
    
    inline void setNumberOfTriggerBits(unsigned int n) { m_trigger_bits.resize(n); }
    inline void setTriggerBit(unsigned int n, bool bit) {m_trigger_bits[n]=bit;}
 
    MuonDQAEventInfo & operator=(const MuonDQAEventInfo &right) {
      if( this != &right ) { 
        this->setRunNumber(right.runNumber());
        this->setEventNumber(right.eventNumber());
        this->setTimeStamp(right.timeStamp());
        this->setOffset(right.ns_Offset());
        this->setTrigType(right.trigType());
        this->setRunTime(right.runningtime());
        this->setLumiBlock(right.lumiBlock());
        this->setTag(right.tag());
        std::vector<bool> trigbits = right.triggerBits();
        this->setNumberOfTriggerBits(trigbits.size());
        for(unsigned int ii=0; ii<trigbits.size(); ii++){
           this->setTriggerBit(ii, trigbits[ii] );
        }
      } 
      return *this; 
    };
 
  private:
    unsigned int m_runNumber;     
    unsigned int m_eventNumber;   
    unsigned int m_timeStamp;     
    unsigned int m_ns_Offset;      // ns Offset member
    std::bitset<8> m_trigType ;         // Trigger Type member
    float m_running_time; // Running Time member
    unsigned int m_lumiBlock;     
 
    std::string  m_tag; 
    std::vector<bool> m_trigger_bits; 
  };
 
std::ostream& operator<<( std::ostream& stream, const MuonDQAEventInfo& info ); 
} //namespace MuonDQA
 
 
 
#endif //MuonDQAEventInfo_h