/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODEventInfo/xAODEventInfo/versions/EventInfo_v1.h

// Dear emacs, this is -*- c++ -*-
// $Id: EventInfo_v1.h 682504 2015-07-13 11:53:50Z krasznaa $
#ifndef XAODEVENTINFO_VERSIONS_EVENTINFO_V1_H
#define XAODEVENTINFO_VERSIONS_EVENTINFO_V1_H

// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <set>
#include <vector>
#include <string>
#include <iosfwd>

// EDM include(s):
#include "AthContainers/AuxElement.h"
#include "AthContainers/DataVector.h"
#include "AthLinks/ElementLink.h"

// Forward declaration(s):
class StoreGateSvc;

namespace xAOD {

   // Some forward declaration(s):
   class EventInfo_v1;
   typedef DataVector< EventInfo_v1 > EventInfoContainer_v1;

   class EventInfo_v1 : public SG::AuxElement {

   public:
      EventInfo_v1();


      uint32_t runNumber() const;
      void setRunNumber( uint32_t value );

      unsigned long long eventNumber() const;
      void setEventNumber( unsigned long long value );

      uint32_t lumiBlock() const;
      void setLumiBlock( uint32_t value );

      uint32_t timeStamp() const;
      void setTimeStamp( uint32_t value );

      uint32_t timeStampNSOffset() const;
      void setTimeStampNSOffset( uint32_t value );

      uint32_t bcid() const;
      void setBCID( uint32_t value );

      uint32_t detectorMask0() const;
      void setDetectorMask0( uint32_t value );
      uint32_t detectorMask1() const;
      void setDetectorMask1( uint32_t value );
      uint32_t detectorMask2() const;
      void setDetectorMask2( uint32_t value );
      uint32_t detectorMask3() const;
      void setDetectorMask3( uint32_t value );

      uint64_t detectorMask() const;
      void setDetectorMask( uint32_t mask0, uint32_t mask1 );
      void setDetectorMask( uint64_t mask );
      uint64_t detectorMaskExt() const;
      void setDetectorMaskExt( uint32_t mask2, uint32_t mask3 );
      void setDetectorMaskExt( uint64_t mask );



      typedef std::vector< std::pair< std::string, std::string > >
         DetDescrTags_t;

      const DetDescrTags_t& detDescrTags() const;
      void setDetDescrTags( const DetDescrTags_t& value );

      uint32_t mcChannelNumber() const;
      void setMCChannelNumber( uint32_t value );

      unsigned long long mcEventNumber() const;
      void setMCEventNumber( unsigned long long value );

      const std::vector< float >& mcEventWeights() const;
      void setMCEventWeights( const std::vector< float >& value );
      float mcEventWeight( size_t i = 0 ) const;

      enum EventType {
         IS_SIMULATION = 1,
         IS_TESTBEAM = 2,
         IS_CALIBRATION = 4
      };

      uint32_t eventTypeBitmask() const;
      void setEventTypeBitmask( uint32_t value );
      bool eventType( EventType type ) const;



      uint32_t statusElement() const;
      void setStatusElement( uint32_t value );

      uint32_t extendedLevel1ID() const;
      void setExtendedLevel1ID( uint32_t value );

      uint16_t level1TriggerType() const;
      void setLevel1TriggerType( uint16_t value );

      class StreamTag {

      public:
         StreamTag( const std::string& name, const std::string& type,
                    bool obeysLumiblock,
                    const std::set< uint32_t >& robs = std::set< uint32_t >(),
                    const std::set< uint32_t >& dets = std::set< uint32_t >() );

         const std::string& name() const;
         const std::string& type() const;
         bool obeysLumiblock() const;
         const std::set< uint32_t >& robs() const;
         const std::set< uint32_t >& dets() const;

      private:
         std::string m_name; 
         std::string m_type; 

         bool m_obeysLumiblock;
         std::set< uint32_t > m_robs; 
         std::set< uint32_t > m_dets; 

      }; // class StreamTag

      const std::vector< StreamTag >& streamTags() const;
      void setStreamTags( const std::vector< StreamTag >& value );



      float actualInteractionsPerCrossing() const;
      void setActualInteractionsPerCrossing( float value );

      float averageInteractionsPerCrossing() const;
      void setAverageInteractionsPerCrossing( float value );

      enum PileUpType {
         Unknown     = 99, 
         Signal      =  0, 
         MinimumBias =  1, 
         Cavern      =  2, 
         HaloGas     =  3, 
         ZeroBias    =  4  
      }; // enum PileUpType

      class SubEvent {

      public:
         SubEvent( uint16_t time, PileUpType type,
                   const ElementLink< EventInfoContainer_v1 >& link );

         uint16_t time() const;
         PileUpType type() const;
         const std::string& typeName() const;

         const ElementLink< EventInfoContainer_v1 >& link() const;
         const EventInfo_v1* ptr() const;

      private:
         uint16_t m_time; 
         PileUpType m_type; 

         ElementLink< EventInfoContainer_v1 > m_link;

      }; // class SubEvent

      const std::vector< SubEvent >& subEvents() const;
      void setSubEvents( const std::vector< SubEvent >& value );



      enum EventFlagSubDet {
         Pixel      = 0, 
         SCT        = 1, 
         TRT        = 2, 
         LAr        = 3, 
         Tile       = 4, 
         Muon       = 5, 
         ForwardDet = 6, 
         Core       = 7, 
         Background = 8, 
         Lumi       = 9, 
         nDets      = 10 
      };

      enum EventFlagErrorState {
         NotSet  = 0, 
         Warning = 1, 
         Error   = 2  
      };

      enum BackgroundEventFlag {
         MBTSTimeDiffHalo       = 0,
         MBTSTimeDiffCol        = 1,
         LArECTimeDiffHalo      = 2,
         LArECTimeDiffCol       = 3,
         PixMultiplicityHuge    = 4,
         PixSPNonEmpty          = 5,
         SCTMultiplicityHuge    = 6,
         SCTSPNonEmpty          = 7,
         CSCTimeDiffHalo        = 8,
         CSCTimeDiffCol         = 9,
         BCMTimeDiffHalo        = 10,
         BCMTimeDiffCol         = 11,
         MuonTimingCol          = 12,
         MuonTimingCosmic       = 13,
         MBTSBeamVeto           = 14,
         BCMBeamVeto            = 15,
         LUCIDBeamVeto          = 16,
         HaloMuonSegment        = 17,
         HaloClusterShape       = 18,
         HaloMuonOneSided       = 19,
         HaloMuonTwoSided       = 20,
         HaloTileClusterPattern = 21,
         BeamGasPixel           = 22,
         CosmicStandAlone       = 23,
         CosmicStandAloneTight  = 24,
         CosmicCombined         = 25,
         CosmicCombinedTight    = 26,
         BkgdResvBit1           = 27,
         BkgdResvBit2           = 28,
         BkgdResvBit3           = 29,
         BkgdResvBit4           = 30,
         BkgdResvBit5           = 31,
         NBackgroundWords       = 32
      };

      uint32_t eventFlags( EventFlagSubDet subDet ) const;
      bool isEventFlagBitSet( EventFlagSubDet subDet, size_t bit ) const;

      bool setEventFlags( EventFlagSubDet subDet, uint32_t flags );
      bool setEventFlagBit( EventFlagSubDet subDet, size_t bit,
                            bool set = true );

      EventFlagErrorState errorState( EventFlagSubDet subDet ) const;
      bool setErrorState( EventFlagSubDet subDet,
                          EventFlagErrorState state );



      float beamPosX() const;
      float beamPosY() const;
      float beamPosZ() const;
      void setBeamPos( float x, float y, float z );

      float beamPosSigmaX() const;
      float beamPosSigmaY() const;
      float beamPosSigmaZ() const;
      void setBeamPosSigma( float x, float y, float z );

      float beamPosSigmaXY() const;
      void setBeamPosSigmaXY( float value );

      float beamTiltXZ() const;
      void setBeamTiltXZ( float value );

      float beamTiltYZ() const;
      void setBeamTiltYZ( float value );

      uint32_t beamStatus() const;
      void setBeamStatus( uint32_t value );



#if not defined(__GCCXML__) and not defined(__ROOTCLING__)
      StoreGateSvc* evtStore() const;
      void setEvtStore( StoreGateSvc* svc );
#endif // not genreflex or rootcint/rootcling


      void toPersistent();
      void toTransient();

   private:
      mutable std::vector< StreamTag > m_streamTags;
      mutable bool m_updateStreamTags;
      mutable std::vector< SubEvent > m_subEvents;
      mutable bool m_updateSubEvents;

#ifndef __GCCXML__
      StoreGateSvc* m_evtStore;
#endif // not __GCCXML__

   }; // class EventInfo_v1

   std::ostream& operator<< ( std::ostream& out, const xAOD::EventInfo_v1& ei );

} // namespace xAOD

// Declare the inheritance of the type:
#include "xAODCore/BaseInfo.h"
SG_BASE( xAOD::EventInfo_v1, SG::AuxElement );

#endif // XAODEVENTINFO_VERSIONS_EVENTINFO_V1_H

---