ByteStreamEventStorageOutputSvc Class Reference

This class provides the services for writing FullEventFragment into file. More...

#include <ByteStreamEventStorageOutputSvc.h>

Inheritance diagram for ByteStreamEventStorageOutputSvc:

Collaboration diagram for ByteStreamEventStorageOutputSvc:

Classes
struct	EventCache

Public Member Functions
	ByteStreamEventStorageOutputSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Constructors:
virtual	~ByteStreamEventStorageOutputSvc ()=default
	Destructor.
StatusCode	initialize () override
	Required of all Gaudi Services.
StatusCode	stop () override
StatusCode	finalize () override
virtual bool	putEvent (const RawEvent *re) override
	Implementation of the IByteStreamOutputSvc interface method putEvent.
virtual bool	putEvent (const RawEvent *re, const EventContext &ctx) override
StatusCode	io_reinit () override

Private Member Functions
StatusCode	reinit ()
	reinitialize the service when a fork() occurred/was-issued
bool	initDataWriter (const EventContext *ctx=nullptr)
	initialize EventStorage's DataWriter
bool	initDataWriterContents (const xAOD::EventInfo *, const ByteStreamMetadata *)
const ByteStreamMetadata *	getByteStreamMetadata ()
const ByteStreamMetadata *	getByteStreamMetadata (const EventContext &ctx)
void	updateDataWriterParameters (DataWriterParameters &) const
	Create DataWriter parameters from job properties.
void	updateDataWriterParameters (DataWriterParameters &params, const xAOD::EventInfo &evtInfo) const
	Create DataWriter parameters from EventInfo.
void	updateDataWriterParameters (DataWriterParameters &params, const ByteStreamMetadata &metaData) const
	Create DataWriter parameters from MetaData.

Private Attributes
Gaudi::Property< std::string >	m_inputDir
	< directory for the data files
Gaudi::Property< std::string >	m_projectTag
	Application Name.
Gaudi::Property< std::string >	m_appName
	File Tag.
Gaudi::Property< std::string >	m_fileTag
	stream type
Gaudi::Property< std::string >	m_streamType
	stream name
Gaudi::Property< std::string >	m_streamName
	EventStorage BS version to produce, "v5" for run1, or "current".
Gaudi::Property< std::string >	m_eventStorageVersion
	stream name for multiple output
Gaudi::Property< std::string >	m_bsOutputStreamName
Gaudi::Property< std::string >	m_simpleFileName
	use this string for filename, not from the "AgreedFileName"
Gaudi::Property< int >	m_lumiBlockNumber
	run number
Gaudi::Property< int >	m_run {this, "RunNumber", 0, "part of filename"}
	Dump fragments.
Gaudi::Property< bool >	m_dump {this, "DumpFlag", false, "dump fragments"}
	Write eventless files.
Gaudi::Property< bool >	m_writeEventless
	Compress events.
Gaudi::Property< bool >	m_compressEvents {this, "CompressEvents", false, ""}
	number of MB per file
Gaudi::Property< unsigned int >	m_maxFileMB
	number of events per file
Gaudi::Property< unsigned int >	m_maxFileNE
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
SG::ReadHandleKey< ByteStreamMetadataContainer >	m_byteStreamMetadataKey
ServiceHandle< IIoComponentMgr >	m_ioMgr {"IoComponentMgr", name()}
ServiceHandle< ITagInfoMgr >	m_tagInfoMgr {"TagInfoMgr", name()}
ServiceHandle< StoreGateSvc >	m_metaDataStore {"StoreGateSvc/MetaDataStore", name()}
int	m_totalEventCounter {0}
	number of event counter
std::unique_ptr< ByteStreamDataWriter >	m_dataWriter
	pointer to DataWriter
std::mutex	m_dataWriterMutex
	mutex to lock data writer during initialization or writing
SG::SlotSpecificObj< EventCache >	m_eventCache
	Cache of event data for each slot.

Detailed Description

This class provides the services for writing FullEventFragment into file.

This class implements the interface IByteStreamOutputSvc for the conversion service to write the output to a file.

Definition at line 49 of file ByteStreamEventStorageOutputSvc.h.

Constructor & Destructor Documentation

ByteStreamEventStorageOutputSvc()

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

Constructors:

Definition at line 30 of file ByteStreamEventStorageOutputSvc.cxx.

  : base_class(name, pSvcLocator) {
}

~ByteStreamEventStorageOutputSvc()

virtual ByteStreamEventStorageOutputSvc::~ByteStreamEventStorageOutputSvc ( )

virtualdefault

Destructor.

Member Function Documentation

finalize()

StatusCode ByteStreamEventStorageOutputSvc::finalize ( )

override

Definition at line 87 of file ByteStreamEventStorageOutputSvc.cxx.

                                          {
  // clean up
  ATH_MSG_DEBUG("deleting DataWriter");
  std::lock_guard< std::mutex > lock(m_dataWriterMutex);
  m_dataWriter.reset();
  ATH_MSG_INFO("number of events written: " << m_totalEventCounter);
  return StatusCode::SUCCESS;
}

getByteStreamMetadata() [1/2]

const ByteStreamMetadata * ByteStreamEventStorageOutputSvc::getByteStreamMetadata ( )

private

Definition at line 240 of file ByteStreamEventStorageOutputSvc.cxx.

{
  SG::ReadHandle<ByteStreamMetadataContainer> metaDataCont (m_byteStreamMetadataKey);
 
  if (!metaDataCont.isValid()) return nullptr;
 
  if (metaDataCont->size() > 1)
    ATH_MSG_WARNING("Multiple run parameters in MetaDataStore. "
                    "Bytestream format only supports one. Arbitrarily "
                    "choosing first.");
 
  return metaDataCont->front();
}

getByteStreamMetadata() [2/2]

const ByteStreamMetadata * ByteStreamEventStorageOutputSvc::getByteStreamMetadata ( const EventContext & ctx )

private

Definition at line 256 of file ByteStreamEventStorageOutputSvc.cxx.

{
  SG::ReadHandle<ByteStreamMetadataContainer> metaDataCont (m_byteStreamMetadataKey, ctx);
 
  if (!metaDataCont.isValid()) return nullptr;
 
  if (metaDataCont->size() > 1)
    ATH_MSG_WARNING("Multiple run parameters in MetaDataStore. "
                    "Bytestream format only supports one. Arbitrarily "
                    "choosing first.");
 
  return metaDataCont->front();
}

initDataWriter()

bool ByteStreamEventStorageOutputSvc::initDataWriter ( const EventContext * ctx = nullptr )

private

initialize EventStorage's DataWriter

Definition at line 98 of file ByteStreamEventStorageOutputSvc.cxx.

                                                                       {
  // Called on first event. Reads run parameters first event and/or first event
  const xAOD::EventInfo* eventInfo = ctx == nullptr
      ? SG::get(m_eventInfoKey)
      : SG::get(m_eventInfoKey, *ctx);
  if (eventInfo == nullptr) ATH_MSG_WARNING("failed to retrieve EventInfo");
 
  const ByteStreamMetadata* metaData = ctx == nullptr ? getByteStreamMetadata() : getByteStreamMetadata(*ctx);
  if (metaData == nullptr)
    ATH_MSG_WARNING("failed to retrieve ByteStreamMetaData");
 
  // Now open a file for writing from retrieved parameters
  return initDataWriterContents(eventInfo, metaData);
}

initDataWriterContents()

bool ByteStreamEventStorageOutputSvc::initDataWriterContents ( const xAOD::EventInfo * evtInfo, const ByteStreamMetadata * metaData )

private

Definition at line 115 of file ByteStreamEventStorageOutputSvc.cxx.

                                        {
  // check that we have sufficient information to do what we need
  if (evtInfo or metaData)
    ATH_MSG_DEBUG("Looking up data writer parameters");
  else
    throw std::runtime_error("Cannot write data without run parameters");
 
  // The heirarchy of run/lumiblock number, GNARR
  //
  //   1) User override
  //   2) Event data
  //   3) File metadata
  //   4) default = unknown = 0
  //
  // Go from 4 to 1 and overwrite
  DataWriterParameters params; 
  if (metaData != nullptr) updateDataWriterParameters(params, *metaData);
  if (evtInfo != nullptr) updateDataWriterParameters(params, *evtInfo);
  updateDataWriterParameters(params);
 
  m_dataWriter = ByteStreamDataWriter::makeWriter(params);
 
  bool result = m_dataWriter->good();
  if (result)
    ATH_MSG_DEBUG("initialized output stream to file with name "
                  << params.fileNameCore);
  else
    ATH_MSG_ERROR("Unable to initialize file");
 
  return result;
}

initialize()

StatusCode ByteStreamEventStorageOutputSvc::initialize ( )

override

Required of all Gaudi Services.

Definition at line 37 of file ByteStreamEventStorageOutputSvc.cxx.

                                            {
  ATH_MSG_INFO("Initializing");
 
  ATH_CHECK(m_eventInfoKey.initialize());
  ATH_CHECK(m_byteStreamMetadataKey.initialize());
  ATH_CHECK(m_tagInfoMgr.retrieve());
  ATH_CHECK(m_metaDataStore.retrieve());
 
  // register this service for 'I/O' events
  ATH_CHECK(m_ioMgr.retrieve());
  ATH_CHECK(m_ioMgr->io_register(this));
 
  // Register output file's name with the I/O manager
  if (!m_simpleFileName.empty()) {
    ATH_CHECK(m_ioMgr->io_register(this, IIoComponentMgr::IoMode::WRITE,
                                   m_simpleFileName));
    ATH_MSG_VERBOSE("io_register[" << this->name() << "]("
                    << m_simpleFileName << ") [ok]");
  }
 
  ATH_CHECK(reinit());
 
  return StatusCode::SUCCESS;
}

io_reinit()

StatusCode ByteStreamEventStorageOutputSvc::io_reinit ( )

override

Definition at line 205 of file ByteStreamEventStorageOutputSvc.cxx.

                                           {
  ATH_MSG_INFO("I/O reinitialization...");
 
  if (!m_ioMgr->io_hasitem(this)) {
    ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
    return StatusCode::FAILURE;
  }
 
  if (!m_simpleFileName.empty()) {
    std::string outputFile = m_simpleFileName;
    ATH_MSG_INFO("I/O reinitialization, file = "  << outputFile);
    std::string &fname = outputFile;
    if (!m_ioMgr->io_contains(this, fname)) {
      ATH_MSG_ERROR("IoComponentMgr does not know about [" << fname << "] !");
      return StatusCode::FAILURE;
    }
    ATH_CHECK(m_ioMgr->io_retrieve(this, fname));
    // all good... copy over.
    // modify directory
    m_inputDir.setValue(outputFile.substr(0, outputFile.find_last_of("/")));
    // FIXME: modify file name, not done for now because of
    // IoUtils.update_io_registry vs. merge conflict.
    //m_simpleFileName.setValue(
    //    outputFile.substr(outputFile.find_last_of("/") + 1));
  }
  ATH_MSG_DEBUG("Deleting DataWriter");
  m_dataWriter.reset();
 
  ATH_CHECK(reinit());
 
  return StatusCode::SUCCESS;
}

putEvent() [1/2]

bool ByteStreamEventStorageOutputSvc::putEvent ( const RawEvent * re )

overridevirtual

Implementation of the IByteStreamOutputSvc interface method putEvent.

Definition at line 151 of file ByteStreamEventStorageOutputSvc.cxx.

                                                            {
  // Read the next event.
  return putEvent(re, Gaudi::Hive::currentContext());
}

putEvent() [2/2]

bool ByteStreamEventStorageOutputSvc::putEvent ( const RawEvent * re, const EventContext & ctx )

overridevirtual

Definition at line 158 of file ByteStreamEventStorageOutputSvc.cxx.

                                                 {
  // Read the next event.
  using OFFLINE_FRAGMENTS_NAMESPACE::DataType;
  using OFFLINE_FRAGMENTS_NAMESPACE::PointerType;
 
  EventCache* cache = m_eventCache.get(ctx);
  cache->releaseEvent();
 
  // we need the size and the start of the event to give to the data writer
  cache->size = re->fragment_size_word();
  ATH_MSG_DEBUG("event size = " << cache->size << ", start = " << re->start());
 
  cache->buffer = std::make_unique< DataType[] >(cache->size);
  std::copy(re->start(), re->start() + cache->size, cache->buffer.get());
 
  {
    // multiple data writers concurrently sounds like a bad idea
    std::lock_guard< std::mutex > lock(m_dataWriterMutex);
 
    // make sure the data writer is ready
    ATH_MSG_DEBUG("looking up data writer");
    if (!m_dataWriter) {
      if (!initDataWriter(&ctx)) {
        ATH_MSG_ERROR("Failed to initialize DataWriter");
        return false;
      }
    }
 
    // write event to disk
    EventStorage::DWError write_result = m_dataWriter->putData(
        sizeof(DataType) * cache->size,
        reinterpret_cast< void* >(cache->buffer.get()));
 
    // Report success or failure
    if (write_result != EventStorage::DWOK) {
      ATH_MSG_ERROR("Failed to write event to DataWriter");
      return false;
    }
    ++m_totalEventCounter;
  }
 
  return true;
}

reinit()

StatusCode ByteStreamEventStorageOutputSvc::reinit ( )

private

reinitialize the service when a fork() occurred/was-issued

Definition at line 64 of file ByteStreamEventStorageOutputSvc.cxx.

                                        {
  ATH_MSG_INFO("Reinitialization...");
  return StatusCode::SUCCESS;
}

stop()

StatusCode ByteStreamEventStorageOutputSvc::stop ( )

override

Definition at line 71 of file ByteStreamEventStorageOutputSvc.cxx.

                                      {
  // Check whether anything has been written and whether the user wants metadata
  // only files
  if (m_dataWriter == 0 and m_writeEventless) {
    const ByteStreamMetadata* metaData = getByteStreamMetadata();
 
    // Try to write metadata to eventless file
    bool dWok = initDataWriterContents(nullptr, metaData);
    if (!dWok) ATH_MSG_WARNING("Could not write Metadata for eventless file");
  }
 
  return StatusCode::SUCCESS;
}

updateDataWriterParameters() [1/3]

void ByteStreamEventStorageOutputSvc::updateDataWriterParameters ( DataWriterParameters & params ) const

private

Create DataWriter parameters from job properties.

Definition at line 273 of file ByteStreamEventStorageOutputSvc.cxx.

                                        {
 
  params.version = 0;
  params.writingPath = m_inputDir;
 
  if (m_run != 0) params.rPar.run_number = m_run;
  ATH_MSG_DEBUG("Run number: " << params.rPar.run_number);
 
  if (m_lumiBlockNumber != 0) params.lumiBlockNumber = m_lumiBlockNumber;
  ATH_MSG_DEBUG("LB number: " << params.lumiBlockNumber);
 
  if (!m_streamType.empty()) params.streamType = m_streamType;
  if (!m_streamName.empty()) params.streamName = m_streamName;
 
  if (params.streamType.empty()) params.streamType = "Single";
  if (params.streamName.empty()) params.streamName = "Stream";
 
  params.stream = params.streamType + "_" + params.streamName;
 
  if (!m_projectTag.empty()) params.project = m_projectTag;
 
  params.applicationName = m_appName;
 
  if (!m_simpleFileName.empty()) {
    // set up for simple file name
    boost::shared_ptr<EventStorage::SimpleFileName> simple_file_name(
        new EventStorage::SimpleFileName(m_simpleFileName));
    params.theFNCB = simple_file_name;
  } else {
    // set up for production file name
    daq::RawFileName fileNameObj(
        params.project,
        params.rPar.run_number,
        params.streamType,
        params.streamName,
        params.lumiBlockNumber,
        params.applicationName);
    params.fileNameCore = fileNameObj.fileNameCore();
  }
 
  params.compression = m_compressEvents
      ? EventStorage::ZLIB
      : EventStorage::NONE;
 
  params.maxFileMB = m_maxFileMB;
  params.maxFileNE = params.rPar.max_events = m_maxFileNE;
}

updateDataWriterParameters() [2/3]

void ByteStreamEventStorageOutputSvc::updateDataWriterParameters ( DataWriterParameters & params, const ByteStreamMetadata & metaData ) const

private

Create DataWriter parameters from MetaData.

Definition at line 402 of file ByteStreamEventStorageOutputSvc.cxx.

                                                                            {
  ATH_MSG_DEBUG("Parsing run parameters from metadata:\n" << metaData); 
 
  params.rPar.run_number = metaData.getRunNumber();
  params.lumiBlockNumber = metaData.getLumiBlock();
 
  const std::string stream = metaData.getStream();
  const std::string::size_type split = stream.find('_');
 
  if (split != std::string::npos and params.streamType.empty())
    params.streamType = stream.substr(0,split);
 
  if (split != std::string::npos and params.streamName.empty())
    params.streamName = stream.substr(split+1);
 
  params.project = metaData.getProject();
  params.maxFileNE = params.rPar.max_events = metaData.getMaxEvents();
 
  params.rPar.rec_enable = metaData.getRecEnable();
  params.rPar.trigger_type = metaData.getTriggerType();
  params.rPar.beam_type = metaData.getBeamType();
  if (metaData.getBeamEnergy() != 0)
    params.rPar.beam_energy = metaData.getBeamEnergy();
 
  params.rPar.detector_mask_LS = metaData.getDetectorMask(); 
  params.rPar.detector_mask_MS = metaData.getDetectorMask2();
 
  for (const std::string& fmd : metaData.getFreeMetaDataStrings())
    params.fmdStrings.push_back(fmd);
  // if(fmd.find("Compression=") == std::string::npos)
}

updateDataWriterParameters() [3/3]

void ByteStreamEventStorageOutputSvc::updateDataWriterParameters ( DataWriterParameters & params, const xAOD::EventInfo & evtInfo ) const

private

Create DataWriter parameters from EventInfo.

Definition at line 324 of file ByteStreamEventStorageOutputSvc.cxx.

                                                                        {
  ATH_MSG_DEBUG("Parsing run parameters from EventInfo" << eventInfo);
  
  params.rPar.run_number = eventInfo.runNumber();
  params.lumiBlockNumber = eventInfo.lumiBlock();
 
  for (const xAOD::EventInfo::StreamTag& tag : eventInfo.streamTags())
    if(!tag.type().empty()) {
      params.streamType = tag.type();
      break;
    }
 
  for (const xAOD::EventInfo::StreamTag& tag : eventInfo.streamTags())
    if (!tag.name().empty()) {
      params.streamName = tag.name();
      break;
    }
 
  for (const auto& tag : eventInfo.detDescrTags())
    params.fmdStrings.push_back(tag.first + ' ' + tag.second);
 
  // Get beam metadata from TagInfo
  std::string beamTypeStr = m_tagInfoMgr->findInputTag("beam_type");
  if (!beamTypeStr.empty()) {
    ATH_MSG_DEBUG("Got beam_type from input file metadata: " << beamTypeStr);
    if (beamTypeStr == "collisions") {
      params.rPar.beam_type = 1;
    } else if (beamTypeStr == "cosmics") {
      params.rPar.beam_type = 0;
    }
  }
 
  std::string beamEnergyStr = m_tagInfoMgr->findInputTag("beam_energy");
  if (!beamEnergyStr.empty()) {
    try {
      params.rPar.beam_energy = std::stoul(beamEnergyStr);
      ATH_MSG_DEBUG("Got beam_energy from input file metadata: " << params.rPar.beam_energy);
    } catch (const std::exception& e) {
      ATH_MSG_WARNING("Could not convert beam_energy '" << beamEnergyStr << "' to number: " << e.what());
    }
  }
 
  // Get IOV metadata strings from MetaDataStore
  const std::vector<std::string>* iovMetaStrings = m_metaDataStore->tryRetrieve<std::vector<std::string>>("IOVMetaDataStrings");
  if (iovMetaStrings != nullptr) {
    ATH_MSG_DEBUG("Retrieved " << iovMetaStrings->size() << " IOV metadata strings from MetaDataStore");
    for (const std::string& str : *iovMetaStrings) {
      params.fmdStrings.push_back(str);
    }
  } else {
    ATH_MSG_DEBUG("No IOV metadata strings found in MetaDataStore (this is normal if not configured)");
  }
 
  params.rPar.trigger_type = eventInfo.level1TriggerType();
  params.rPar.detector_mask_LS = eventInfo.detectorMask();
  params.rPar.detector_mask_MS = eventInfo.detectorMaskExt();
 
  std::string event_type = "Event type: sim/data - ";
  if (eventInfo.eventType(xAOD::EventInfo::EventType::IS_SIMULATION))
    event_type += "is sim";
  else event_type += "is data";
 
  event_type += " , testbeam/atlas - ";
  if (eventInfo.eventType(xAOD::EventInfo::EventType::IS_TESTBEAM))
    event_type += "is testbeam";
  else event_type += "is atlas";
 
  event_type += " , calibration/physics - ";
  if (eventInfo.eventType(xAOD::EventInfo::EventType::IS_CALIBRATION))
    event_type += "is calibration";
  else event_type += "is physics";
 
  params.fmdStrings.push_back(std::move(event_type));
}

Member Data Documentation

m_appName

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_appName

private

Initial value:

{this, "AppName", "",
    "part of filename"}

File Tag.

Definition at line 83 of file ByteStreamEventStorageOutputSvc.h.

                                    {this, "AppName", "",
    "part of filename"};

m_bsOutputStreamName

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_bsOutputStreamName

private

Initial value:

{this, "BSOutputStreamName",
    name(), "stream name for multiple output"}

Definition at line 105 of file ByteStreamEventStorageOutputSvc.h.

                                               {this, "BSOutputStreamName",
    name(), "stream name for multiple output"};

m_byteStreamMetadataKey

SG::ReadHandleKey< ByteStreamMetadataContainer > ByteStreamEventStorageOutputSvc::m_byteStreamMetadataKey

private

Initial value:

{this,
    "ByteStreamMetadataKey", "MetaDataStore+ByteStreamMetadata",
    "Key for bytestream metadata object in metadata store"}

Definition at line 140 of file ByteStreamEventStorageOutputSvc.h.

                                                                        {this,
    "ByteStreamMetadataKey", "MetaDataStore+ByteStreamMetadata",
    "Key for bytestream metadata object in metadata store"};

m_compressEvents

Gaudi::Property<bool> ByteStreamEventStorageOutputSvc::m_compressEvents {this, "CompressEvents", false, ""}

private

number of MB per file

Definition at line 127 of file ByteStreamEventStorageOutputSvc.h.

{this, "CompressEvents", false, ""};

m_dataWriter

std::unique_ptr<ByteStreamDataWriter> ByteStreamEventStorageOutputSvc::m_dataWriter

private

pointer to DataWriter

Definition at line 153 of file ByteStreamEventStorageOutputSvc.h.

m_dataWriterMutex

std::mutex ByteStreamEventStorageOutputSvc::m_dataWriterMutex

private

mutex to lock data writer during initialization or writing

Definition at line 156 of file ByteStreamEventStorageOutputSvc.h.

m_dump

Gaudi::Property<bool> ByteStreamEventStorageOutputSvc::m_dump {this, "DumpFlag", false, "dump fragments"}

private

Write eventless files.

Definition at line 120 of file ByteStreamEventStorageOutputSvc.h.

{this, "DumpFlag", false, "dump fragments"};

m_eventCache

SG::SlotSpecificObj<EventCache> ByteStreamEventStorageOutputSvc::m_eventCache

private

Cache of event data for each slot.

Definition at line 182 of file ByteStreamEventStorageOutputSvc.h.

m_eventInfoKey

SG::ReadHandleKey< xAOD::EventInfo > ByteStreamEventStorageOutputSvc::m_eventInfoKey

private

Initial value:

{this, "EventInfoKey",
    "EventInfo", "Key for EventInfo object in event store"}

Definition at line 137 of file ByteStreamEventStorageOutputSvc.h.

                                                 {this, "EventInfoKey",
    "EventInfo", "Key for EventInfo object in event store"};

m_eventStorageVersion

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_eventStorageVersion

private

Initial value:

{this,
    "EventStorageVersion", "current", "Version of the ByteStream file data, "
        "use \"v5\" or \"run1\" for run1, \"current\" for most current version "
        "(default)."}

stream name for multiple output

Definition at line 99 of file ByteStreamEventStorageOutputSvc.h.

                                                {this,
    "EventStorageVersion", "current", "Version of the ByteStream file data, "
        "use \"v5\" or \"run1\" for run1, \"current\" for most current version "
        "(default)."};

m_fileTag

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_fileTag

private

Initial value:

{this, "FileTag", "",
    "part of filename"}

stream type

Definition at line 87 of file ByteStreamEventStorageOutputSvc.h.

                                    {this, "FileTag", "",
    "part of filename"};

m_inputDir

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_inputDir

private

Initial value:

{this, "OutputDirectory", "",
    "directory for the data files"}

< directory for the data files

Project Tag

Definition at line 75 of file ByteStreamEventStorageOutputSvc.h.

                                     {this, "OutputDirectory", "",
    "directory for the data files"};

m_ioMgr

ServiceHandle< IIoComponentMgr > ByteStreamEventStorageOutputSvc::m_ioMgr {"IoComponentMgr", name()}

private

Definition at line 144 of file ByteStreamEventStorageOutputSvc.h.

{"IoComponentMgr", name()};

m_lumiBlockNumber

Gaudi::Property<int> ByteStreamEventStorageOutputSvc::m_lumiBlockNumber

private

Initial value:

{this, "LumiBlockNumber", 0,
    "part of filename"}

run number

Definition at line 113 of file ByteStreamEventStorageOutputSvc.h.

                                      {this, "LumiBlockNumber", 0,
    "part of filename"};

m_maxFileMB

Gaudi::Property<unsigned int> ByteStreamEventStorageOutputSvc::m_maxFileMB

private

Initial value:

{this, "MaxFileMB", 10000,
    "MB per file"}

number of events per file

Definition at line 130 of file ByteStreamEventStorageOutputSvc.h.

                                         {this, "MaxFileMB", 10000,
    "MB per file"};

m_maxFileNE

Gaudi::Property<unsigned int> ByteStreamEventStorageOutputSvc::m_maxFileNE

private

Initial value:

{this, "MaxFileNE", 100000,
    "evens per file"}

Definition at line 134 of file ByteStreamEventStorageOutputSvc.h.

                                         {this, "MaxFileNE", 100000,
    "evens per file"};

m_metaDataStore

ServiceHandle< StoreGateSvc > ByteStreamEventStorageOutputSvc::m_metaDataStore {"StoreGateSvc/MetaDataStore", name()}

private

Definition at line 146 of file ByteStreamEventStorageOutputSvc.h.

{"StoreGateSvc/MetaDataStore", name()};

m_projectTag

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_projectTag

private

Initial value:

{this, "ProjectTag", "",
    "part of filename"}

Application Name.

Definition at line 79 of file ByteStreamEventStorageOutputSvc.h.

                                       {this, "ProjectTag", "",
    "part of filename"};

m_run

Gaudi::Property<int> ByteStreamEventStorageOutputSvc::m_run {this, "RunNumber", 0, "part of filename"}

private

Dump fragments.

Definition at line 117 of file ByteStreamEventStorageOutputSvc.h.

{this, "RunNumber", 0, "part of filename"};

m_simpleFileName

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_simpleFileName

private

Initial value:

{this, "SimpleFileName", "",
    "for filename not from AgreedFileName"}

use this string for filename, not from the "AgreedFileName"

luminosity block number

Definition at line 109 of file ByteStreamEventStorageOutputSvc.h.

                                           {this, "SimpleFileName", "",
    "for filename not from AgreedFileName"};

m_streamName

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_streamName

private

Initial value:

{this, "StreamName", "",
    "part of filename"}

EventStorage BS version to produce, "v5" for run1, or "current".

Definition at line 95 of file ByteStreamEventStorageOutputSvc.h.

                                       {this, "StreamName", "",
    "part of filename"};

m_streamType

Gaudi::Property<std::string> ByteStreamEventStorageOutputSvc::m_streamType

private

Initial value:

{this, "StreamType",  "",
    "part of filename"}

stream name

Definition at line 91 of file ByteStreamEventStorageOutputSvc.h.

                                       {this, "StreamType",  "",
    "part of filename"};

m_tagInfoMgr

ServiceHandle< ITagInfoMgr > ByteStreamEventStorageOutputSvc::m_tagInfoMgr {"TagInfoMgr", name()}

private

Definition at line 145 of file ByteStreamEventStorageOutputSvc.h.

{"TagInfoMgr", name()};

m_totalEventCounter

int ByteStreamEventStorageOutputSvc::m_totalEventCounter {0}

private

number of event counter

Definition at line 150 of file ByteStreamEventStorageOutputSvc.h.

{0};

m_writeEventless

Gaudi::Property<bool> ByteStreamEventStorageOutputSvc::m_writeEventless

private

Initial value:

{this, "WriteEventlessFiles", true,
    ""}

Compress events.

Definition at line 123 of file ByteStreamEventStorageOutputSvc.h.

                                      {this, "WriteEventlessFiles", true,
    ""};

---

The documentation for this class was generated from the following files:

• ByteStreamEventStorageOutputSvc.h
• ByteStreamEventStorageOutputSvc.cxx