v40_write_FullEventFragment.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef OFFLINE_EFORMAT_V40_WRITE_FULLEVENTFRAGMENT_H
#define OFFLINE_EFORMAT_V40_WRITE_FULLEVENTFRAGMENT_H
 
#include "v40_write_ROBFragment.h"
#include "CxxUtils/checker_macros.h"
#include <cstring>
 
namespace offline_eformat {
 
  namespace v40_write {
 
    const uint32_t MAX_UNCHECKED_FRAGMENTS = 2048;
 
    class FullEventFragment
    {
    public:
 
      FullEventFragment (uint32_t source_id, uint32_t bc_time_secs,
             uint32_t bc_time_nsec, uint32_t global_id, uint32_t run_type,
             uint32_t run_no, uint16_t lumi_block,
             uint32_t lvl1_id, uint16_t bc_id, uint8_t lvl1_type);
 
      FullEventFragment (const uint32_t* fe);
 
      FullEventFragment ();
 
      FullEventFragment (const FullEventFragment& other) = delete;
      FullEventFragment& operator= (const FullEventFragment& other) = delete;
 
      virtual ~FullEventFragment ();
 
      void copy_header(const uint32_t* other);
      void copy_header(const FullEventFragment& other);
 
      void status (uint32_t n, const uint32_t* status);
 
      inline uint32_t nstatus (void) const { return m_node[0].base[5]; }
 
      inline const uint32_t* status (void) const { return m_node[1].base; }
 
      inline void minor_version (uint16_t v) {
          eformat::helper::Version version(v, eformat::MAJOR_V40_VERSION);
          m_node[0].base[3] = version.code();
      }
 
      inline uint16_t minor_version (void) const 
      { return 0xffff & m_node[0].base[3]; }
 
      inline void source_id (uint32_t s) 
      { m_node[0].base[4] = s; }
 
      inline uint32_t source_id (void) const 
      { return m_node[0].base[4]; }
 
      void checksum_type (uint32_t s);
 
      inline uint32_t checksum_type (void) const { return m_node[2].base[0]; }
 
      inline void bc_time_seconds (uint32_t s) 
      { m_node[2].base[1] = s; }
 
      inline void bc_time_nanoseconds (uint32_t s) 
      { m_node[2].base[2] = s; }
 
      inline uint32_t bc_time_seconds (void) const 
      { return m_node[2].base[1]; }
 
      inline uint32_t bc_time_nanoseconds (void) const 
      { return m_node[2].base[2]; }
 
      inline void global_id (uint32_t s) 
      { m_node[2].base[3] = s; }
 
      inline uint32_t global_id (void) const
      { return m_node[2].base[3]; }
 
      inline void run_type (uint32_t s) 
      { m_node[2].base[4] = s; }
 
      inline uint32_t run_type (void) const 
      { return m_node[2].base[4]; }
 
      inline void run_no (uint32_t s) 
      { m_node[2].base[5] = s; }
 
      inline uint32_t run_no (void) const 
      { return m_node[2].base[5]; }
 
      inline void lumi_block (uint16_t s) 
      { m_node[2].base[6] = s; }
 
      inline uint16_t lumi_block (void) const 
      { return m_node[2].base[6]; }
 
      inline void lvl1_id (uint32_t s) 
      { m_node[2].base[7] = s; }
 
      inline uint32_t lvl1_id (void) const 
      { return m_node[2].base[7]; }
 
      inline void bc_id (uint16_t s) 
      { m_node[2].base[8] = s; }
 
      inline uint16_t bc_id (void) const 
      { return m_node[2].base[8]; }
 
      inline void lvl1_trigger_type (uint8_t s) 
      { m_node[2].base[9] = s; }
 
      inline uint8_t lvl1_trigger_type (void) const 
      { return m_node[2].base[9]; }
 
      void lvl1_trigger_info (uint32_t n, const uint32_t* data);
 
      inline uint32_t nlvl1_trigger_info (void) const 
      { return m_node[2].base[10]; }
 
      inline const uint32_t* lvl1_trigger_info (void) const 
      { return m_node[3].base; }
 
      void lvl2_trigger_info (uint32_t n, const uint32_t* data);
 
      inline uint32_t nlvl2_trigger_info (void) const 
      { return m_node[4].base[0]; }
 
      inline const uint32_t* lvl2_trigger_info (void) const 
      { return m_node[5].base; }
 
      void event_filter_info (uint32_t n, const uint32_t* data);
 
      inline uint32_t nevent_filter_info (void) const 
      { return m_node[6].base[0]; }
 
      inline const uint32_t* event_filter_info (void) const 
      { return m_node[7].base; }
 
      inline uint32_t nstream_tag (void) const 
      { return m_node[8].base[0]; }
 
      void stream_tag (uint32_t n, const uint32_t* data);
 
      inline const uint32_t* stream_tag (void) const { return m_node[9].base; }
 
      inline uint32_t meta_size_word (void) const
      { return m_node[0].base[2] + (checksum_type()?1:0); }
 
      inline uint32_t size_word (void) const
      { return m_node[0].base[1]; }
      
      void append (v40_write::ROBFragment* rob);
 
      void append_unchecked (const uint32_t* rob);
 
      inline uint32_t nunchecked_fragments (void) const
      { return m_n_unchecked; }
 
      const uint32_t* unchecked_fragment (uint32_t n) const;
      
      inline const v40_write::ROBFragment* first_child (void) const
      { return m_child; }
 
      inline void size_change (uint32_t o, uint32_t n)
      { m_node[0].base[1] -= o; m_node[0].base[1] += n; }
 
      uint32_t page_count (void) const;
 
      const eformat::write::node_t* bind (void);
 
    private: //to make the code simpler
 
      void initialize(void);
 
    private: //representation
 
      uint32_t m_header[20]; 
      eformat::write::node_t m_node[12]; 
      v40_write::ROBFragment* m_child; 
      v40_write::ROBFragment* m_last; 
      uint32_t m_checksum; 
      uint32_t m_n_unchecked; 
      eformat::write::node_t m_unchecked[MAX_UNCHECKED_FRAGMENTS]; 
 
    };
 
  }
  
}
 
#endif /* EFORMAT_WRITE_FULLEVENTFRAGMENT_H */