ByteStreamEventStorageOutputSvc.h

Go to the documentation of this file.

/* Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration */
 
#ifndef BYTESTREAMCNVSVC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H
#define BYTESTREAMCNVSVC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H

#include <memory>
#include <mutex>
#include <string>
 
#include "ByteStreamDataWriter.h"
#include "ByteStreamCnvSvcBase/IByteStreamOutputSvc.h"
 
#include "AthenaKernel/SlotSpecificObj.h"
#include "AthenaBaseComps/AthService.h"
#include "ByteStreamData/ByteStreamMetadataContainer.h"
#include "ByteStreamData/RawEvent.h"
#include "EventStorage/EventStorageRecords.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/StoreGateSvc.h"
#include "xAODEventInfo/EventInfo.h"
 
#include "GaudiKernel/extends.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/IIoComponentMgr.h"
#include "GaudiKernel/ServiceHandle.h"
#include "EventInfoMgt/ITagInfoMgr.h"
 
 
class EventInfo;
class ByteStreamMetadata;
 

class ByteStreamEventStorageOutputSvc :
  public extends< AthService, IByteStreamOutputSvc, IIoComponent > {
 public:

  ByteStreamEventStorageOutputSvc(
      const std::string& name, ISvcLocator* pSvcLocator);

  virtual ~ByteStreamEventStorageOutputSvc() = default;

  StatusCode initialize() override;
  StatusCode stop() override;
  StatusCode finalize() 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()};
  ServiceHandle< ITagInfoMgr > m_tagInfoMgr{"TagInfoMgr", name()};
  ServiceHandle< StoreGateSvc > m_metaDataStore{"StoreGateSvc/MetaDataStore", 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  // BYTESTREAMCNVSVC_BYTESTREAMEVENTSTORAGEOUTPUTSVC_H