ByteStreamEventStorageOutputSvc.h

Go to the documentation of this file.

/* Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration */
 
#ifndef EVENT_BYTESTREAMCNVSVC_SRC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H_
#define EVENT_BYTESTREAMCNVSVC_SRC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H_
 
#include <memory>
#include <mutex>
#include <string>
 
#include "ByteStreamDataWriter.h"
#include "ByteStreamCnvSvc/ByteStreamOutputSvc.h"
 
#include "AthenaKernel/SlotSpecificObj.h"
#include "ByteStreamData/ByteStreamMetadataContainer.h"
#include "ByteStreamData/RawEvent.h"
#include "EventStorage/EventStorageRecords.h"
#include "StoreGate/ReadHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
 
#include "GaudiKernel/extends.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/IIoComponentMgr.h" 
#include "GaudiKernel/ServiceHandle.h"
 
 
class EventInfo;
class ByteStreamMetadata;
 
 
class ByteStreamEventStorageOutputSvc :
    public extends< ByteStreamOutputSvc, IIoComponent > {
 public:
  using extends::extends;
 
  ByteStreamEventStorageOutputSvc(
      const std::string& name, ISvcLocator* pSvcLocator);
 
  virtual ~ByteStreamEventStorageOutputSvc() {}
 
  StatusCode initialize() override;
  StatusCode stop() override;
  StatusCode finalize() override;
  StatusCode
      queryInterface(const InterfaceID& riid, void** ppvInterface) override;
 
 
  virtual bool putEvent(const RawEvent* re) override;
  virtual bool putEvent(const RawEvent* re, const EventContext& ctx) override;
 
  // Callback method to reinitialize the internal state of the component
  // for I/O purposes (e.g. upon @c fork(2))
  StatusCode io_reinit() override;
 
 private:  // properties
  Gaudi::Property<std::string> m_inputDir{this, "OutputDirectory", "",
    "directory for the data files"};
 
  Gaudi::Property<std::string> m_projectTag{this, "ProjectTag", "",
    "part of filename"};
 
  Gaudi::Property<std::string> m_appName{this, "AppName", "",
    "part of filename"};
 
  Gaudi::Property<std::string> m_fileTag{this, "FileTag", "",
    "part of filename"};
 
  Gaudi::Property<std::string> m_streamType{this, "StreamType",  "",
    "part of filename"};
 
  Gaudi::Property<std::string> m_streamName{this, "StreamName", "",
    "part of filename"};
 
  Gaudi::Property<std::string> m_eformatVersion{this, "EformatVersion",
    "current", "Version of the event format data, use \"v40\" or \"run1\" "
    "for run1, \"current\" for most current version (default)."};
 
  Gaudi::Property<std::string> m_eventStorageVersion{this,
    "EventStorageVersion", "current", "Version of the ByteStream file data, "
        "use \"v5\" or \"run1\" for run1, \"current\" for most current version "
        "(default)."};
 
  Gaudi::Property<std::string> m_bsOutputStreamName{this, "BSOutputStreamName",
    name(), "stream name for multiple output"};
 
  Gaudi::Property<std::string> m_simpleFileName{this, "SimpleFileName", "",
    "for filename not from AgreedFileName"};
 
  Gaudi::Property<int> m_lumiBlockNumber{this, "LumiBlockNumber", 0,
    "part of filename"};
 
  Gaudi::Property<int> m_run{this, "RunNumber", 0, "part of filename"};
 
  Gaudi::Property<bool> m_dump{this, "DumpFlag", false, "dump fragments"};
 
  Gaudi::Property<bool> m_writeEventless{this, "WriteEventlessFiles", true,
    ""};
 
  Gaudi::Property<bool> m_compressEvents{this, "CompressEvents", false, ""};
 
  Gaudi::Property<unsigned int> m_maxFileMB{this, "MaxFileMB", 10000,
    "MB per file"};
 
  Gaudi::Property<unsigned int> m_maxFileNE{this, "MaxFileNE", 100000,
    "evens per file"};
 
  SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey{this, "EventInfoKey",
    "EventInfo", "Key for EventInfo object in event store"};
 
  SG::ReadHandleKey< ByteStreamMetadataContainer > m_byteStreamMetadataKey{this,
    "ByteStreamMetadataKey", "MetaDataStore+ByteStreamMetadata",
    "Key for bytestream metadata object in metadata store"};
 
  ServiceHandle< IIoComponentMgr > m_ioMgr{"IoComponentMgr", name()};
 
 private:  // data
  int m_totalEventCounter{0};
 
  bool m_isRun1{false};
 
  std::unique_ptr<ByteStreamDataWriter> m_dataWriter;
 
  std::mutex m_dataWriterMutex;
 
 private:  // internal helper functions
  StatusCode reinit();
 
  bool initDataWriter(const EventContext* ctx = nullptr);
  bool initDataWriterContents(
      const xAOD::EventInfo*, const ByteStreamMetadata*);
  const ByteStreamMetadata * getByteStreamMetadata();
  const ByteStreamMetadata * getByteStreamMetadata(const EventContext& ctx);
 
  struct EventCache {
    inline void releaseEvent() {
      buffer.reset(nullptr);
      size = 0;
    }
 
    std::unique_ptr< uint32_t[] > buffer{nullptr};
 
    unsigned int size{0};
  };
 
  SG::SlotSpecificObj<EventCache> m_eventCache;
 
  void updateDataWriterParameters(DataWriterParameters&) const;
 
  void updateDataWriterParameters(DataWriterParameters& params,
                                  const xAOD::EventInfo& evtInfo) const;
 
  void updateDataWriterParameters(DataWriterParameters& params,
                                  const ByteStreamMetadata& metaData) const;
 
};
 
#endif  // EVENT_BYTESTREAMCNVSVC_SRC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H_