EventInfo_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODEVENTINFO_VERSIONS_EVENTINFO_V1_H
#define XAODEVENTINFO_VERSIONS_EVENTINFO_V1_H
 
// System include(s):
#include <stdint.h>  // global namespace typenames
#include <set>
#include <vector>
#include <string>
#include <iosfwd>
 
// EDM include(s):
#include "AthContainers/AuxElement.h"
#include "AthContainers/DataVector.h"
#include "AthLinks/ElementLink.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/checker_macros.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();
      EventInfo_v1( const EventInfo_v1& parent );
 
      EventInfo_v1& operator=( const EventInfo_v1& rhs );
 
 
      uint32_t runNumber() const;
      void setRunNumber( uint32_t value );
 
      uint64_t eventNumber() const;
      void setEventNumber( uint64_t 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 );
 
      uint64_t mcEventNumber() const;
      void setMCEventNumber( uint64_t 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 );
 
      struct PileUpMixtureID {
         uint64_t lowBits{};
         uint64_t highBits{};
      };
 
      PileUpMixtureID pileUpMixtureID() const;
      void setPileUpMixtureID( const PileUpMixtureID &value );
 
      uint64_t pileUpMixtureIDLowBits() const;
      void setPileUpMixtureIDLowBits( uint64_t value );
 
      uint64_t pileUpMixtureIDHighBits() const;
      void setPileUpMixtureIDHighBits( uint64_t value );
 
      enum PileUpType {
         Unknown     = 99, 
         Signal      =  0, 
         MinimumBias =  1, 
         Cavern      =  2, 
         HaloGas     =  3, 
         HighPtMinimumBias = 4, 
         ZeroBias    = 5,  
         PileUp_NTYPES
      }; // enum PileUpType
 
      static const std::string& PileUpType2Name(PileUpType typ);
 
      static PileUpType PileUpInt2Type(unsigned short typ);
 
      class SubEvent {
 
      public:
         SubEvent( int16_t time, uint16_t index, PileUpType type,
                   const ElementLink< EventInfoContainer_v1 >& link );
 
         int16_t time() const;
         uint16_t index() const;
         PileUpType type() const;
         const std::string& typeName() const;
 
         const ElementLink< EventInfoContainer_v1 >& link() const;
         const EventInfo_v1* ptr() const;
 
      private:
         int16_t m_time; 
         uint16_t m_index; 
         PileUpType m_type; 
         ElementLink< EventInfoContainer_v1 > m_link;
 
      }; // class SubEvent
 
      const std::vector< SubEvent >& subEvents() const;
      void setSubEvents( const std::vector< SubEvent >& value );
      void addSubEvent( const SubEvent& subEvent );
      void clearSubEvents();
 
 
 
      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 ) const;
      bool resetEventFlagBit( EventFlagSubDet subDet, size_t bit );
 
      EventFlagErrorState errorState( EventFlagSubDet subDet ) const;
      bool setErrorState( EventFlagSubDet subDet,
                          EventFlagErrorState state );
 
 
      bool updateEventFlagBit ( const EventFlagSubDet subDet,
                                const size_t bit ) const;
      bool updateEventFlags( const EventFlagSubDet subDet,
                             const uint32_t flags_in ) const;
      bool updateErrorState( const EventFlagSubDet subDet,
                             const EventFlagErrorState state ) const;
 
 
 
      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 );
 
      float beamSpotWeight() const;
      bool hasBeamSpotWeight() const;
      void setBeamSpotWeight( float value );
 
 
 
#if not defined(__GCCXML__) and not defined(__ROOTCLING__)
      StoreGateSvc* evtStore ATLAS_NOT_CONST_THREAD_SAFE () const;
      void setEvtStore( StoreGateSvc* svc );
#endif // not genreflex or rootcint/rootcling
 
 
      void toPersistent();
      void toTransient();
 
   private:
      std::vector< EventInfo_v1::SubEvent > makeSubEvents() const;
 
      CxxUtils::CachedValue<std::vector< StreamTag > > m_streamTags;
      CxxUtils::CachedValue<std::vector< SubEvent>  > m_subEvents;
 
#ifndef __GCCXML__
      StoreGateSvc* m_evtStore;
#endif // not __GCCXML__
 
   }; // class EventInfo_v1
 
   std::ostream& operator<< ( std::ostream& out, const xAOD::EventInfo_v1& ei );
   std::ostream& operator<< ( std::ostream& out, const xAOD::EventInfo_v1::PileUpMixtureID& id );
   bool operator== ( const xAOD::EventInfo_v1::PileUpMixtureID& a, const xAOD::EventInfo_v1::PileUpMixtureID& b );
 
} // 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